regenerated client

samples/client/wordnik-api/python3/wordnik/AccountApi.py

@@ -29,13 +29,17 @@ class AccountApi(object):
       self.apiClient = apiClient
 
     
+
     def authenticate(self, username, password, **kwargs):
         """Authenticates a User
 
         Args:
             username, str: A confirmed Wordnik username (required)
+
             password, str: The user's password (required)
 
+            
+
         Returns: AuthenticationToken
         """
 
@@ -73,13 +77,18 @@ class AccountApi(object):
         return responseObject
         
 
+        
+
     def authenticatePost(self, username, body, **kwargs):
         """Authenticates a user
 
         Args:
             username, str: A confirmed Wordnik username (required)
+
             body, str: The user's password (required)
 
+            
+
         Returns: AuthenticationToken
         """
 
@@ -115,14 +124,20 @@ class AccountApi(object):
         return responseObject
         
 
+        
+
     def getWordListsForLoggedInUser(self, auth_token, **kwargs):
         """Fetches WordList objects for the logged-in user.
 
         Args:
             auth_token, str: auth_token of logged-in user (required)
+
             skip, int: Results to skip (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: list[WordList]
         """
 
@@ -160,12 +175,16 @@ class AccountApi(object):
         return responseObject
         
 
+        
+
     def getApiTokenStatus(self, **kwargs):
         """Returns usage statistics for the API account.
 
         Args:
             api_key, str: Wordnik authentication token (optional)
 
+            
+
         Returns: ApiTokenStatus
         """
 
@@ -199,12 +218,16 @@ class AccountApi(object):
         return responseObject
         
 
+        
+
     def getLoggedInUser(self, auth_token, **kwargs):
         """Returns the logged-in User
 
         Args:
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: User
         """
 
@@ -241,3 +264,7 @@ class AccountApi(object):
         
 
     
+
+
+
+

samples/client/wordnik-api/python3/wordnik/WordApi.py

@@ -29,16 +29,23 @@ class WordApi(object):
       self.apiClient = apiClient
 
     
+
     def getExamples(self, word, **kwargs):
         """Returns examples for a word
 
         Args:
             word, str: Word to return examples for (required)
+
             includeDuplicates, str: Show duplicate examples from different sources (optional)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             skip, int: Results to skip (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: ExampleSearchResults
         """
 
@@ -82,14 +89,20 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getWord(self, word, **kwargs):
         """Given a word as a string, returns the WordObject that represents it
 
         Args:
             word, str: String value of WordObject to return (required)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             includeSuggestions, str: Return suggestions (for correct spelling, case variants, etc.) (optional)
 
+            
+
         Returns: WordObject
         """
 
@@ -129,18 +142,28 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getDefinitions(self, word, **kwargs):
         """Return definitions for a word
 
         Args:
             word, str: Word to return definitions for (required)
+
             partOfSpeech, str: CSV list of part-of-speech types (optional)
+
             sourceDictionaries, str: Source dictionary to return definitions from.  If 'all' is received, results are returned from all sources. If multiple values are received (e.g. 'century,wiktionary'), results are returned from the first specified dictionary that has definitions. If left blank, results are returned from the first dictionary that has definitions. By default, dictionaries are searched in this order: ahd, wiktionary, webster, century, wordnet (optional)
+
             limit, int: Maximum number of results to return (optional)
+
             includeRelated, str: Return related words with definitions (optional)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             includeTags, str: Return a closed set of XML tags in response (optional)
 
+            
+
         Returns: list[Definition]
         """
 
@@ -188,13 +211,18 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getTopExample(self, word, **kwargs):
         """Returns a top example for a word
 
         Args:
             word, str: Word to fetch examples for (required)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
 
+            
+
         Returns: Example
         """
 
@@ -232,15 +260,22 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getRelatedWords(self, word, **kwargs):
         """Given a word as a string, returns relationships from the Word Graph
 
         Args:
             word, str: Word to fetch relationships for (required)
+
             relationshipTypes, str: Limits the total results per type of relationship type (optional)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             limitPerRelationshipType, int: Restrict to the supplied relatinship types (optional)
 
+            
+
         Returns: list[Related]
         """
 
@@ -282,16 +317,24 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getTextPronunciations(self, word, **kwargs):
         """Returns text pronunciations for a given word
 
         Args:
             word, str: Word to get pronunciations for (required)
+
             sourceDictionary, str: Get from a single dictionary (optional)
+
             typeFormat, str: Text pronunciation type (optional)
+
             useCanonical, str: If true will try to return a correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: list[TextPron]
         """
 
@@ -335,15 +378,22 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getHyphenation(self, word, **kwargs):
         """Returns syllable information for a word
 
         Args:
             word, str: Word to get syllables for (required)
+
             sourceDictionary, str: Get from a single dictionary. Valid options: ahd, century, wiktionary, webster, and wordnet. (optional)
+
             useCanonical, str: If true will try to return a correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: list[Syllable]
         """
 
@@ -385,15 +435,22 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getWordFrequency(self, word, **kwargs):
         """Returns word usage over time
 
         Args:
             word, str: Word to return (required)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
+
             startYear, int: Starting Year (optional)
+
             endYear, int: Ending Year (optional)
 
+            
+
         Returns: FrequencySummary
         """
 
@@ -435,15 +492,22 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getPhrases(self, word, **kwargs):
         """Fetches bi-gram phrases for a word
 
         Args:
             word, str: Word to fetch phrases for (required)
+
             limit, int: Maximum number of results to return (optional)
+
             wlmi, int: Minimum WLMI for the phrase (optional)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
 
+            
+
         Returns: list[Bigram]
         """
 
@@ -485,13 +549,18 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getEtymologies(self, word, **kwargs):
         """Fetches etymology data
 
         Args:
             word, str: Word to return (required)
+
             useCanonical, str: If true will try to return the correct word root ('cats' -> 'cat'). If false returns exactly what was requested. (optional)
 
+            
+
         Returns: list[str]
         """
 
@@ -529,14 +598,20 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getAudio(self, word, **kwargs):
         """Fetches audio metadata for a word.
 
         Args:
             word, str: Word to get audio for. (required)
+
             useCanonical, str: Use the canonical form of the word (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: list[AudioFile]
         """
 
@@ -576,12 +651,16 @@ class WordApi(object):
         return responseObject
         
 
+        
+
     def getScrabbleScore(self, word, **kwargs):
         """Returns the Scrabble score for a word
 
         Args:
             word, str: Word to get scrabble score for. (required)
 
+            
+
         Returns: ScrabbleScoreResult
         """
 
@@ -620,3 +699,7 @@ class WordApi(object):
         
 
     
+
+
+
+

samples/client/wordnik-api/python3/wordnik/WordListApi.py

@@ -29,14 +29,19 @@ class WordListApi(object):
       self.apiClient = apiClient
 
     
+
     def updateWordList(self, permalink, auth_token, **kwargs):
         """Updates an existing WordList
 
         Args:
             permalink, str: permalink of WordList to update (required)
+
             body, WordList: Updated WordList (optional)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: 
         """
 
@@ -69,13 +74,18 @@ class WordListApi(object):
 
         
 
+        
+
     def deleteWordList(self, permalink, auth_token, **kwargs):
         """Deletes an existing WordList
 
         Args:
             permalink, str: ID of WordList to delete (required)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: 
         """
 
@@ -108,13 +118,18 @@ class WordListApi(object):
 
         
 
+        
+
     def getWordListByPermalink(self, permalink, auth_token, **kwargs):
         """Fetches a WordList by ID
 
         Args:
             permalink, str: permalink of WordList to fetch (required)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: WordList
         """
 
@@ -152,14 +167,20 @@ class WordListApi(object):
         return responseObject
         
 
+        
+
     def addWordsToWordList(self, permalink, auth_token, **kwargs):
         """Adds words to a WordList
 
         Args:
             permalink, str: permalink of WordList to user (required)
+
             body, list[StringValue]: Array of words to add to WordList (optional)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: 
         """
 
@@ -192,17 +213,26 @@ class WordListApi(object):
 
         
 
+        
+
     def getWordListWords(self, permalink, auth_token, **kwargs):
         """Fetches words in a WordList
 
         Args:
             permalink, str: ID of WordList to use (required)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
+
             sortBy, str: Field to sort by (optional)
+
             sortOrder, str: Direction to sort (optional)
+
             skip, int: Results to skip (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: list[WordListWord]
         """
 
@@ -248,14 +278,20 @@ class WordListApi(object):
         return responseObject
         
 
+        
+
     def deleteWordsFromWordList(self, permalink, auth_token, **kwargs):
         """Removes words from a WordList
 
         Args:
             permalink, str: permalink of WordList to use (required)
+
             body, list[StringValue]: Words to remove from WordList (optional)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: 
         """
 
@@ -291,3 +327,7 @@ class WordListApi(object):
         
 
     
+
+
+
+

samples/client/wordnik-api/python3/wordnik/WordListsApi.py

@@ -29,13 +29,17 @@ class WordListsApi(object):
       self.apiClient = apiClient
 
     
+
     def createWordList(self, auth_token, **kwargs):
         """Creates a WordList.
 
         Args:
             body, WordList: WordList to create (optional)
+
             auth_token, str: The auth token of the logged-in user, obtained by calling /account.{format}/authenticate/{username} (described above) (required)
 
+            
+
         Returns: WordList
         """
 
@@ -72,3 +76,7 @@ class WordListsApi(object):
         
 
     
+
+
+
+

samples/client/wordnik-api/python3/wordnik/WordsApi.py

@@ -29,23 +29,37 @@ class WordsApi(object):
       self.apiClient = apiClient
 
     
+
     def searchWords(self, query, **kwargs):
         """Searches words
 
         Args:
             query, str: Search query (required)
+
             includePartOfSpeech, str: Only include these comma-delimited parts of speech (optional)
+
             excludePartOfSpeech, str: Exclude these comma-delimited parts of speech (optional)
+
             caseSensitive, str: Search case sensitive (optional)
+
             minCorpusCount, int: Minimum corpus frequency for terms (optional)
+
             maxCorpusCount, int: Maximum corpus frequency for terms (optional)
+
             minDictionaryCount, int: Minimum number of dictionary entries for words returned (optional)
+
             maxDictionaryCount, int: Maximum dictionary definition count (optional)
+
             minLength, int: Minimum word length (optional)
+
             maxLength, int: Maximum word length (optional)
+
             skip, int: Results to skip (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: WordSearchResults
         """
 
@@ -103,12 +117,16 @@ class WordsApi(object):
         return responseObject
         
 
+        
+
     def getWordOfTheDay(self, **kwargs):
         """Returns a specific WordOfTheDay
 
         Args:
             date, str: Fetches by date in yyyy-MM-dd (optional)
 
+            
+
         Returns: WordOfTheDay
         """
 
@@ -142,27 +160,46 @@ class WordsApi(object):
         return responseObject
         
 
+        
+
     def reverseDictionary(self, query, **kwargs):
         """Reverse dictionary search
 
         Args:
             query, str: Search term (required)
+
             findSenseForWord, str: Restricts words and finds closest sense (optional)
+
             includeSourceDictionaries, str: Only include these comma-delimited source dictionaries (optional)
+
             excludeSourceDictionaries, str: Exclude these comma-delimited source dictionaries (optional)
+
             includePartOfSpeech, str: Only include these comma-delimited parts of speech (optional)
+
             excludePartOfSpeech, str: Exclude these comma-delimited parts of speech (optional)
+
             expandTerms, str: Expand terms (optional)
+
             sortBy, str: Attribute to sort by (optional)
+
             sortOrder, str: Sort direction (optional)
+
             minCorpusCount, int: Minimum corpus frequency for terms (optional)
+
             maxCorpusCount, int: Maximum corpus frequency for terms (optional)
+
             minLength, int: Minimum word length (optional)
+
             maxLength, int: Maximum word length (optional)
+
             includeTags, str: Return a closed set of XML tags in response (optional)
+
             skip, str: Results to skip (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: DefinitionSearchResults
         """
 
@@ -226,23 +263,38 @@ class WordsApi(object):
         return responseObject
         
 
+        
+
     def getRandomWords(self, **kwargs):
         """Returns an array of random WordObjects
 
         Args:
             includePartOfSpeech, str: CSV part-of-speech values to include (optional)
+
             excludePartOfSpeech, str: CSV part-of-speech values to exclude (optional)
+
             sortBy, str: Attribute to sort by (optional)
+
             sortOrder, str: Sort direction (optional)
+
             hasDictionaryDef, str: Only return words with dictionary definitions (optional)
+
             minCorpusCount, int: Minimum corpus frequency for terms (optional)
+
             maxCorpusCount, int: Maximum corpus frequency for terms (optional)
+
             minDictionaryCount, int: Minimum dictionary count (optional)
+
             maxDictionaryCount, int: Maximum dictionary count (optional)
+
             minLength, int: Minimum word length (optional)
+
             maxLength, int: Maximum word length (optional)
+
             limit, int: Maximum number of results to return (optional)
 
+            
+
         Returns: list[WordObject]
         """
 
@@ -298,20 +350,32 @@ class WordsApi(object):
         return responseObject
         
 
+        
+
     def getRandomWord(self, **kwargs):
         """Returns a single random WordObject
 
         Args:
             includePartOfSpeech, str: CSV part-of-speech values to include (optional)
+
             excludePartOfSpeech, str: CSV part-of-speech values to exclude (optional)
+
             hasDictionaryDef, str: Only return words with dictionary definitions (optional)
+
             minCorpusCount, int: Minimum corpus frequency for terms (optional)
+
             maxCorpusCount, int: Maximum corpus frequency for terms (optional)
+
             minDictionaryCount, int: Minimum dictionary count (optional)
+
             maxDictionaryCount, int: Maximum dictionary count (optional)
+
             minLength, int: Minimum word length (optional)
+
             maxLength, int: Maximum word length (optional)
 
+            
+
         Returns: WordObject
         """
 
@@ -364,3 +428,7 @@ class WordsApi(object):
         
 
     
+
+
+
+