loafle/openapi-generator
3
0
Fork 0
forked from loafle/openapi-generator-original
Code Pull Requests Activity

Fix typo

Browse Source
This commit is contained in:
geekerzp 2015-07-02 15:13:54 +08:00
parent 88e5860d9b
commit 0e8cf70dc4
4 changed files with 63 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
modules/swagger-codegen/src/main/resources/python/api.mustache
View File

@ -48,16 +48,17 @@ class {{classname}}(object):
{{{notes}}}
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.{{nickname}}({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
{{#allParams}}:param {{dataType}} {{paramName}}: {{{description}}} {{#required}}(required){{/required}}{{#optional}}(optional){{/optional}}
{{/allParams}}
:return: {{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}None{{/returnType}}
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
{{#allParams}}{{#required}}
# verify the required parameter '{{paramName}}' is set

40
samples/client/petstore/python/swagger_client/apis/pet_api.py
View File

@ -47,16 +47,17 @@ class PetApi(object):
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_pet(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param Pet body: Pet object that needs to be added to the store
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['body']
@ -111,17 +112,18 @@ class PetApi(object):
:param Pet body: Pet object that needs to be added to the store (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.add_pet(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param Pet body: Pet object that needs to be added to the store
>>>>>>> support asynchronous request in python client
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['body']
@ -180,17 +182,18 @@ class PetApi(object):
:param list[str] status: Status values that need to be considered for filter (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.find_pets_by_status(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param list[str] status: Status values that need to be considered for filter
>>>>>>> support asynchronous request in python client
:return: list[Pet]
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['status']
@ -250,17 +253,18 @@ class PetApi(object):
:param list[str] tags: Tags to filter by (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.find_pets_by_tags(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param list[str] tags: Tags to filter by
>>>>>>> support asynchronous request in python client
:return: list[Pet]
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['tags']
@ -317,16 +321,17 @@ class PetApi(object):
Returns a pet when ID < 10. ID > 10 or nonintegers will simulate API error conditions
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_pet_by_id(pet_id, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param int pet_id: ID of pet that needs to be fetched (required)
:return: Pet
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'pet_id' is set
@ -387,18 +392,19 @@ class PetApi(object):
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_pet_with_form(pet_id, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str pet_id: ID of pet that needs to be updated (required)
:param str name: Updated name of the pet (optional)
:param str status: Updated status of the pet (optional)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'pet_id' is set
@ -466,19 +472,20 @@ class PetApi(object):
<<<<<<< HEAD
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_pet(pet_id, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str api_key:
>>>>>>> support asynchronous request in python client
:param int pet_id: Pet id to delete (required)
:param str api_key: (optional)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'pet_id' is set
@ -545,18 +552,19 @@ class PetApi(object):
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.upload_file(pet_id, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param int pet_id: ID of pet to update (required)
:param str additional_metadata: Additional data to pass to server (optional)
:param file file: file to upload (optional)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'pet_id' is set

20
samples/client/petstore/python/swagger_client/apis/store_api.py
View File

@ -47,15 +47,16 @@ class StoreApi(object):
Returns a map of status codes to quantities
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_inventory(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:return: dict(str, int)
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = []
@ -112,17 +113,18 @@ class StoreApi(object):
:param Order body: order placed for purchasing the pet (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.place_order(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param Order body: order placed for purchasing the pet
>>>>>>> support asynchronous request in python client
:return: Order
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['body']
@ -179,16 +181,17 @@ class StoreApi(object):
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_order_by_id(order_id, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str order_id: ID of pet that needs to be fetched (required)
:return: Order
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'order_id' is set
@ -249,16 +252,17 @@ class StoreApi(object):
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_order(order_id, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str order_id: ID of the order that needs to be deleted (required)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'order_id' is set

40
samples/client/petstore/python/swagger_client/apis/user_api.py
View File

@ -50,17 +50,18 @@ class UserApi(object):
:param User body: Created user object (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_user(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param User body: Created user object
>>>>>>> support asynchronous request in python client
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['body']
@ -119,17 +120,18 @@ class UserApi(object):
:param list[User] body: List of user object (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_users_with_array_input(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param list[User] body: List of user object
>>>>>>> support asynchronous request in python client
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['body']
@ -188,17 +190,18 @@ class UserApi(object):
:param list[User] body: List of user object (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_users_with_list_input(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param list[User] body: List of user object
>>>>>>> support asynchronous request in python client
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['body']
@ -258,18 +261,19 @@ class UserApi(object):
:param str password: The password for login in clear text (optional)
=======
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.login_user(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str username: The user name for login
:param str password: The password for login in clear text
>>>>>>> support asynchronous request in python client
:return: str
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = ['username', 'password']
@ -329,15 +333,16 @@ class UserApi(object):
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.logout_user(callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
all_params = []
@ -390,16 +395,17 @@ class UserApi(object):
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_user_by_name(username, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str username: The name that needs to be fetched. Use user1 for testing. (required)
:return: User
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'username' is set
@ -460,17 +466,18 @@ class UserApi(object):
This can only be done by the logged in user.
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_user(username, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str username: name that need to be deleted (required)
:param User body: Updated user object (optional)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'username' is set
@ -533,16 +540,17 @@ class UserApi(object):
This can only be done by the logged in user.
SDK also supports asynchronous requests in which you can define a `callback` function
to be passed along and invoked when recives response:
to be passed along and invoked when receiving response:
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_user(username, callback=callback_function)
:param callback function: The callback function for asynchronous request. (optional)
:param str username: The name that needs to be deleted (required)
:return: None
If the method called asynchronously, returns the request thread.
If the method is called asynchronously, returns the request thread.
"""
# verify the required parameter 'username' is set