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

[Python] Fixed docstrings in api.mustache (#6391)

Browse Source 
* [Python] Fixed docstrings

Fixes https://github.com/swagger-api/swagger-codegen/issues/9630

* Updated generated files

* Fixed python-experimental

* Updated generated files

* Fully fixed the format of the docstrings

* Updated generated files

* Updated generated files in openapi3
This commit is contained in:
Alexey Volkov 2020-06-04 08:46:35 -07:00 committed by GitHub
parent e708cdc83e
commit 6f6c8ede79
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
240 changed files with 3920 additions and 1882 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

23
modules/openapi-generator/src/main/resources/python/api.mustache vendored
View File

@ -38,6 +38,7 @@ class {{classname}}(object):
{{/notes}}
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
{{#sortParamsByRequiredFlag}}
>>> thread = api.{{operationId}}({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}async_req=True)
{{/sortParamsByRequiredFlag}}
@ -46,20 +47,24 @@ class {{classname}}(object):
{{/sortParamsByRequiredFlag}}
>>> result = thread.get()
:param async_req bool: execute request asynchronously
{{#allParams}}
:param {{dataType}} {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}}
:param {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}}
:type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}}
{{/allParams}}
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: {{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}None{{/returnType}}
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: {{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}None{{/returnType}}
"""
kwargs['_return_http_data_only'] = True
return self.{{operationId}}_with_http_info({{#sortParamsByRequiredFlag}}{{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}{{/sortParamsByRequiredFlag}}**kwargs) # noqa: E501
@ -72,6 +77,7 @@ class {{classname}}(object):
{{/notes}}
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
{{#sortParamsByRequiredFlag}}
>>> thread = api.{{operationId}}_with_http_info({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}async_req=True)
{{/sortParamsByRequiredFlag}}
@ -80,22 +86,27 @@ class {{classname}}(object):
{{/sortParamsByRequiredFlag}}
>>> result = thread.get()
:param async_req bool: execute request asynchronously
{{#allParams}}
:param {{dataType}} {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional{{#defaultValue}}, default to {{{.}}}{{/defaultValue}}){{/optional}}
:param {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}}
:type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}}
{{/allParams}}
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: {{#returnType}}tuple({{returnType}}, status_code(int), headers(HTTPHeaderDict)){{/returnType}}{{^returnType}}None{{/returnType}}
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: {{#returnType}}tuple({{returnType}}, status_code(int), headers(HTTPHeaderDict)){{/returnType}}{{^returnType}}None{{/returnType}}
"""
{{#servers.0}}

2
modules/openapi-generator/src/main/resources/python/model.mustache vendored
View File

@ -107,7 +107,7 @@ class {{classname}}(object):
{{/description}}
:param {{name}}: The {{name}} of this {{classname}}. # noqa: E501
:type: {{dataType}}
:type {{name}}: {{dataType}}
"""
{{^isNullable}}
{{#required}}

1
modules/openapi-generator/src/main/resources/python/python-experimental/api.mustache vendored
View File

@ -66,6 +66,7 @@ class {{classname}}(object):
{{/notes}}
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.{{operationId}}({{#requiredParams}}{{^defaultValue}}{{paramName}}, {{/defaultValue}}{{/requiredParams}}{{#requiredParams}}{{#defaultValue}}{{paramName}}={{{defaultValue}}}, {{/defaultValue}}{{/requiredParams}}async_req=True)
>>> result = thread.get()

15
modules/openapi-generator/src/main/resources/python/python-experimental/api_client.mustache vendored
View File

@ -291,6 +291,7 @@ class ApiClient(object):
({str: (bool, str, int, float, date, datetime, str, none_type)},)
:param _check_type: boolean, whether to check the types of the data
received from the server
:type _check_type: bool
:return: deserialized object.
"""
@ -350,22 +351,28 @@ class ApiClient(object):
(float, none_type)
([int, none_type],)
({str: (bool, str, int, float, date, datetime, str, none_type)},)
:param files dict: key -> field name, value -> a list of open file
:param files: key -> field name, value -> a list of open file
objects for `multipart/form-data`.
:type files: dict
:param async_req bool: execute request asynchronously
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param collection_formats: dict of collection formats for path, query,
header, and post parameters.
:type collection_formats: dict, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _check_type: boolean describing if the data back from the server
should have its type checked.
:type _check_type: bool, optional
:return:
If async_req parameter is True,
the request will be called asynchronously.
@ -559,9 +566,9 @@ class ApiClient(object):
:param headers: Header parameters dict to be updated.
:param querys: Query parameters tuple list to be updated.
:param auth_settings: Authentication setting identifiers list.
:resource_path: A string representation of the HTTP request resource path.
:method: A string representation of the HTTP request method.
:body: A object representing the body of the HTTP request.
:param resource_path: A string representation of the HTTP request resource path.
:param method: A string representation of the HTTP request method.
:param body: A object representing the body of the HTTP request.
The object type is the return value of sanitize_for_serialization().
"""
if not auth_settings:

23
samples/client/petstore/python-asyncio/petstore_api/api/another_fake_api.py
View File

@ -42,21 +42,26 @@ class AnotherFakeApi(object):
To test special tags and operation ID starting with number # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.call_123_test_special_tags(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Client
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Client
"""
kwargs['_return_http_data_only'] = True
return self.call_123_test_special_tags_with_http_info(body, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class AnotherFakeApi(object):
To test special tags and operation ID starting with number # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.call_123_test_special_tags_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Client, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

508
samples/client/petstore/python-asyncio/petstore_api/api/fake_api.py
View File

File diff suppressed because it is too large Load Diff

23
samples/client/petstore/python-asyncio/petstore_api/api/fake_classname_tags_123_api.py
View File

@ -42,21 +42,26 @@ class FakeClassnameTags123Api(object):
To test class name in snake case # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_classname(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Client
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Client
"""
kwargs['_return_http_data_only'] = True
return self.test_classname_with_http_info(body, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class FakeClassnameTags123Api(object):
To test class name in snake case # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_classname_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Client, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

249
samples/client/petstore/python-asyncio/petstore_api/api/pet_api.py
View File

@ -41,21 +41,26 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_pet(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.add_pet_with_http_info(body, **kwargs) # noqa: E501
@ -65,23 +70,29 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_pet_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -153,22 +164,28 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_pet(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: Pet id to delete (required)
:param str api_key:
:param pet_id: Pet id to delete (required)
:type pet_id: int
:param api_key:
:type api_key: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.delete_pet_with_http_info(pet_id, **kwargs) # noqa: E501
@ -178,24 +195,31 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_pet_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: Pet id to delete (required)
:param str api_key:
:param pet_id: Pet id to delete (required)
:type pet_id: int
:param api_key:
:type api_key: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -267,21 +291,26 @@ class PetApi(object):
Multiple status values can be provided with comma separated strings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_status(status, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] status: Status values that need to be considered for filter (required)
:param status: Status values that need to be considered for filter (required)
:type status: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: list[Pet]
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: list[Pet]
"""
kwargs['_return_http_data_only'] = True
return self.find_pets_by_status_with_http_info(status, **kwargs) # noqa: E501
@ -292,23 +321,29 @@ class PetApi(object):
Multiple status values can be provided with comma separated strings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_status_with_http_info(status, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] status: Status values that need to be considered for filter (required)
:param status: Status values that need to be considered for filter (required)
:type status: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -382,21 +417,26 @@ class PetApi(object):
Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_tags(tags, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] tags: Tags to filter by (required)
:param tags: Tags to filter by (required)
:type tags: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: list[Pet]
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: list[Pet]
"""
kwargs['_return_http_data_only'] = True
return self.find_pets_by_tags_with_http_info(tags, **kwargs) # noqa: E501
@ -407,23 +447,29 @@ class PetApi(object):
Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_tags_with_http_info(tags, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] tags: Tags to filter by (required)
:param tags: Tags to filter by (required)
:type tags: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -497,21 +543,26 @@ class PetApi(object):
Returns a single pet # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_pet_by_id(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to return (required)
:param pet_id: ID of pet to return (required)
:type pet_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Pet
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Pet
"""
kwargs['_return_http_data_only'] = True
return self.get_pet_by_id_with_http_info(pet_id, **kwargs) # noqa: E501
@ -522,23 +573,29 @@ class PetApi(object):
Returns a single pet # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_pet_by_id_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to return (required)
:param pet_id: ID of pet to return (required)
:type pet_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Pet, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Pet, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -610,21 +667,26 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.update_pet_with_http_info(body, **kwargs) # noqa: E501
@ -634,23 +696,29 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -722,23 +790,30 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_form(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet that needs to be updated (required)
:param str name: Updated name of the pet
:param str status: Updated status of the pet
:param pet_id: ID of pet that needs to be updated (required)
:type pet_id: int
:param name: Updated name of the pet
:type name: str
:param status: Updated status of the pet
:type status: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.update_pet_with_form_with_http_info(pet_id, **kwargs) # noqa: E501
@ -748,25 +823,33 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_form_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet that needs to be updated (required)
:param str name: Updated name of the pet
:param str status: Updated status of the pet
:param pet_id: ID of pet that needs to be updated (required)
:type pet_id: int
:param name: Updated name of the pet
:type name: str
:param status: Updated status of the pet
:type status: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -844,23 +927,30 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param str additional_metadata: Additional data to pass to server
:param file file: file to upload
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param file: file to upload
:type file: file
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: ApiResponse
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: ApiResponse
"""
kwargs['_return_http_data_only'] = True
return self.upload_file_with_http_info(pet_id, **kwargs) # noqa: E501
@ -870,25 +960,33 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param str additional_metadata: Additional data to pass to server
:param file file: file to upload
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param file: file to upload
:type file: file
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -970,23 +1068,30 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_required_file(pet_id, required_file, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param file required_file: file to upload (required)
:param str additional_metadata: Additional data to pass to server
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param required_file: file to upload (required)
:type required_file: file
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: ApiResponse
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: ApiResponse
"""
kwargs['_return_http_data_only'] = True
return self.upload_file_with_required_file_with_http_info(pet_id, required_file, **kwargs) # noqa: E501
@ -996,25 +1101,33 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_required_file_with_http_info(pet_id, required_file, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param file required_file: file to upload (required)
:param str additional_metadata: Additional data to pass to server
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param required_file: file to upload (required)
:type required_file: file
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

86
samples/client/petstore/python-asyncio/petstore_api/api/store_api.py
View File

@ -42,21 +42,26 @@ class StoreApi(object):
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_order(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str order_id: ID of the order that needs to be deleted (required)
:param order_id: ID of the order that needs to be deleted (required)
:type order_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.delete_order_with_http_info(order_id, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class StoreApi(object):
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_order_with_http_info(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str order_id: ID of the order that needs to be deleted (required)
:param order_id: ID of the order that needs to be deleted (required)
:type order_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -152,20 +163,24 @@ class StoreApi(object):
Returns a map of status codes to quantities # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inventory(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: dict(str, int)
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: dict(str, int)
"""
kwargs['_return_http_data_only'] = True
return self.get_inventory_with_http_info(**kwargs) # noqa: E501
@ -176,22 +191,27 @@ class StoreApi(object):
Returns a map of status codes to quantities # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inventory_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(dict(str, int), status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(dict(str, int), status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -257,21 +277,26 @@ class StoreApi(object):
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_order_by_id(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int order_id: ID of pet that needs to be fetched (required)
:param order_id: ID of pet that needs to be fetched (required)
:type order_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Order
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Order
"""
kwargs['_return_http_data_only'] = True
return self.get_order_by_id_with_http_info(order_id, **kwargs) # noqa: E501
@ -282,23 +307,29 @@ class StoreApi(object):
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_order_by_id_with_http_info(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int order_id: ID of pet that needs to be fetched (required)
:param order_id: ID of pet that needs to be fetched (required)
:type order_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Order, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -374,21 +405,26 @@ class StoreApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.place_order(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Order body: order placed for purchasing the pet (required)
:param body: order placed for purchasing the pet (required)
:type body: Order
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Order
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Order
"""
kwargs['_return_http_data_only'] = True
return self.place_order_with_http_info(body, **kwargs) # noqa: E501
@ -398,23 +434,29 @@ class StoreApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.place_order_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Order body: order placed for purchasing the pet (required)
:param body: order placed for purchasing the pet (required)
:type body: Order
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Order, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

190
samples/client/petstore/python-asyncio/petstore_api/api/user_api.py
View File

@ -42,21 +42,26 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_user(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param User body: Created user object (required)
:param body: Created user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.create_user_with_http_info(body, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_user_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param User body: Created user object (required)
:param body: Created user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -151,21 +162,26 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_array_input(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.create_users_with_array_input_with_http_info(body, **kwargs) # noqa: E501
@ -175,23 +191,29 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_array_input_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -259,21 +281,26 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_list_input(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.create_users_with_list_input_with_http_info(body, **kwargs) # noqa: E501
@ -283,23 +310,29 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_list_input_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -368,21 +401,26 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_user(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be deleted (required)
:param username: The name that needs to be deleted (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.delete_user_with_http_info(username, **kwargs) # noqa: E501
@ -393,23 +431,29 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_user_with_http_info(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be deleted (required)
:param username: The name that needs to be deleted (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -477,21 +521,26 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_by_name(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be fetched. Use user1 for testing. (required)
:param username: The name that needs to be fetched. Use user1 for testing. (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: User
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: User
"""
kwargs['_return_http_data_only'] = True
return self.get_user_by_name_with_http_info(username, **kwargs) # noqa: E501
@ -501,23 +550,29 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_by_name_with_http_info(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be fetched. Use user1 for testing. (required)
:param username: The name that needs to be fetched. Use user1 for testing. (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(User, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(User, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -589,22 +644,28 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_user(username, password, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The user name for login (required)
:param str password: The password for login in clear text (required)
:param username: The user name for login (required)
:type username: str
:param password: The password for login in clear text (required)
:type password: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: str
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: str
"""
kwargs['_return_http_data_only'] = True
return self.login_user_with_http_info(username, password, **kwargs) # noqa: E501
@ -614,24 +675,31 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_user_with_http_info(username, password, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The user name for login (required)
:param str password: The password for login in clear text (required)
:param username: The user name for login (required)
:type username: str
:param password: The password for login in clear text (required)
:type password: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(str, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(str, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -710,20 +778,24 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_user(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.logout_user_with_http_info(**kwargs) # noqa: E501
@ -733,22 +805,27 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_user_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -810,22 +887,28 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_user(username, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: name that need to be deleted (required)
:param User body: Updated user object (required)
:param username: name that need to be deleted (required)
:type username: str
:param body: Updated user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.update_user_with_http_info(username, body, **kwargs) # noqa: E501
@ -836,24 +919,31 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_user_with_http_info(username, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: name that need to be deleted (required)
:param User body: Updated user object (required)
:param username: name that need to be deleted (required)
:type username: str
:param body: Updated user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_any_type.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesAnyType(object):
:param name: The name of this AdditionalPropertiesAnyType. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_array.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesArray(object):
:param name: The name of this AdditionalPropertiesArray. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_boolean.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesBoolean(object):
:param name: The name of this AdditionalPropertiesBoolean. # noqa: E501
:type: str
:type name: str
"""
self._name = name

22
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_class.py
View File

@ -118,7 +118,7 @@ class AdditionalPropertiesClass(object):
:param map_string: The map_string of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, str)
:type map_string: dict(str, str)
"""
self._map_string = map_string
@ -139,7 +139,7 @@ class AdditionalPropertiesClass(object):
:param map_number: The map_number of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, float)
:type map_number: dict(str, float)
"""
self._map_number = map_number
@ -160,7 +160,7 @@ class AdditionalPropertiesClass(object):
:param map_integer: The map_integer of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, int)
:type map_integer: dict(str, int)
"""
self._map_integer = map_integer
@ -181,7 +181,7 @@ class AdditionalPropertiesClass(object):
:param map_boolean: The map_boolean of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, bool)
:type map_boolean: dict(str, bool)
"""
self._map_boolean = map_boolean
@ -202,7 +202,7 @@ class AdditionalPropertiesClass(object):
:param map_array_integer: The map_array_integer of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, list[int])
:type map_array_integer: dict(str, list[int])
"""
self._map_array_integer = map_array_integer
@ -223,7 +223,7 @@ class AdditionalPropertiesClass(object):
:param map_array_anytype: The map_array_anytype of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, list[object])
:type map_array_anytype: dict(str, list[object])
"""
self._map_array_anytype = map_array_anytype
@ -244,7 +244,7 @@ class AdditionalPropertiesClass(object):
:param map_map_string: The map_map_string of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, dict(str, str))
:type map_map_string: dict(str, dict(str, str))
"""
self._map_map_string = map_map_string
@ -265,7 +265,7 @@ class AdditionalPropertiesClass(object):
:param map_map_anytype: The map_map_anytype of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, dict(str, object))
:type map_map_anytype: dict(str, dict(str, object))
"""
self._map_map_anytype = map_map_anytype
@ -286,7 +286,7 @@ class AdditionalPropertiesClass(object):
:param anytype_1: The anytype_1 of this AdditionalPropertiesClass. # noqa: E501
:type: object
:type anytype_1: object
"""
self._anytype_1 = anytype_1
@ -307,7 +307,7 @@ class AdditionalPropertiesClass(object):
:param anytype_2: The anytype_2 of this AdditionalPropertiesClass. # noqa: E501
:type: object
:type anytype_2: object
"""
self._anytype_2 = anytype_2
@ -328,7 +328,7 @@ class AdditionalPropertiesClass(object):
:param anytype_3: The anytype_3 of this AdditionalPropertiesClass. # noqa: E501
:type: object
:type anytype_3: object
"""
self._anytype_3 = anytype_3

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_integer.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesInteger(object):
:param name: The name of this AdditionalPropertiesInteger. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_number.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesNumber(object):
:param name: The name of this AdditionalPropertiesNumber. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_object.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesObject(object):
:param name: The name of this AdditionalPropertiesObject. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_string.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesString(object):
:param name: The name of this AdditionalPropertiesString. # noqa: E501
:type: str
:type name: str
"""
self._name = name

4
samples/client/petstore/python-asyncio/petstore_api/models/animal.py
View File

@ -78,7 +78,7 @@ class Animal(object):
:param class_name: The class_name of this Animal. # noqa: E501
:type: str
:type class_name: str
"""
if self.local_vars_configuration.client_side_validation and class_name is None: # noqa: E501
raise ValueError("Invalid value for `class_name`, must not be `None`") # noqa: E501
@ -101,7 +101,7 @@ class Animal(object):
:param color: The color of this Animal. # noqa: E501
:type: str
:type color: str
"""
self._color = color

6
samples/client/petstore/python-asyncio/petstore_api/models/api_response.py
View File

@ -78,7 +78,7 @@ class ApiResponse(object):
:param code: The code of this ApiResponse. # noqa: E501
:type: int
:type code: int
"""
self._code = code
@ -99,7 +99,7 @@ class ApiResponse(object):
:param type: The type of this ApiResponse. # noqa: E501
:type: str
:type type: str
"""
self._type = type
@ -120,7 +120,7 @@ class ApiResponse(object):
:param message: The message of this ApiResponse. # noqa: E501
:type: str
:type message: str
"""
self._message = message

2
samples/client/petstore/python-asyncio/petstore_api/models/array_of_array_of_number_only.py
View File

@ -68,7 +68,7 @@ class ArrayOfArrayOfNumberOnly(object):
:param array_array_number: The array_array_number of this ArrayOfArrayOfNumberOnly. # noqa: E501
:type: list[list[float]]
:type array_array_number: list[list[float]]
"""
self._array_array_number = array_array_number

2
samples/client/petstore/python-asyncio/petstore_api/models/array_of_number_only.py
View File

@ -68,7 +68,7 @@ class ArrayOfNumberOnly(object):
:param array_number: The array_number of this ArrayOfNumberOnly. # noqa: E501
:type: list[float]
:type array_number: list[float]
"""
self._array_number = array_number

6
samples/client/petstore/python-asyncio/petstore_api/models/array_test.py
View File

@ -78,7 +78,7 @@ class ArrayTest(object):
:param array_of_string: The array_of_string of this ArrayTest. # noqa: E501
:type: list[str]
:type array_of_string: list[str]
"""
self._array_of_string = array_of_string
@ -99,7 +99,7 @@ class ArrayTest(object):
:param array_array_of_integer: The array_array_of_integer of this ArrayTest. # noqa: E501
:type: list[list[int]]
:type array_array_of_integer: list[list[int]]
"""
self._array_array_of_integer = array_array_of_integer
@ -120,7 +120,7 @@ class ArrayTest(object):
:param array_array_of_model: The array_array_of_model of this ArrayTest. # noqa: E501
:type: list[list[ReadOnlyFirst]]
:type array_array_of_model: list[list[ReadOnlyFirst]]
"""
self._array_array_of_model = array_array_of_model

2
samples/client/petstore/python-asyncio/petstore_api/models/big_cat.py
View File

@ -68,7 +68,7 @@ class BigCat(object):
:param kind: The kind of this BigCat. # noqa: E501
:type: str
:type kind: str
"""
allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501
if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501

2
samples/client/petstore/python-asyncio/petstore_api/models/big_cat_all_of.py
View File

@ -68,7 +68,7 @@ class BigCatAllOf(object):
:param kind: The kind of this BigCatAllOf. # noqa: E501
:type: str
:type kind: str
"""
allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501
if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501

12
samples/client/petstore/python-asyncio/petstore_api/models/capitalization.py
View File

@ -93,7 +93,7 @@ class Capitalization(object):
:param small_camel: The small_camel of this Capitalization. # noqa: E501
:type: str
:type small_camel: str
"""
self._small_camel = small_camel
@ -114,7 +114,7 @@ class Capitalization(object):
:param capital_camel: The capital_camel of this Capitalization. # noqa: E501
:type: str
:type capital_camel: str
"""
self._capital_camel = capital_camel
@ -135,7 +135,7 @@ class Capitalization(object):
:param small_snake: The small_snake of this Capitalization. # noqa: E501
:type: str
:type small_snake: str
"""
self._small_snake = small_snake
@ -156,7 +156,7 @@ class Capitalization(object):
:param capital_snake: The capital_snake of this Capitalization. # noqa: E501
:type: str
:type capital_snake: str
"""
self._capital_snake = capital_snake
@ -177,7 +177,7 @@ class Capitalization(object):
:param sca_eth_flow_points: The sca_eth_flow_points of this Capitalization. # noqa: E501
:type: str
:type sca_eth_flow_points: str
"""
self._sca_eth_flow_points = sca_eth_flow_points
@ -200,7 +200,7 @@ class Capitalization(object):
Name of the pet # noqa: E501
:param att_name: The att_name of this Capitalization. # noqa: E501
:type: str
:type att_name: str
"""
self._att_name = att_name

2
samples/client/petstore/python-asyncio/petstore_api/models/cat.py
View File

@ -68,7 +68,7 @@ class Cat(object):
:param declawed: The declawed of this Cat. # noqa: E501
:type: bool
:type declawed: bool
"""
self._declawed = declawed

2
samples/client/petstore/python-asyncio/petstore_api/models/cat_all_of.py
View File

@ -68,7 +68,7 @@ class CatAllOf(object):
:param declawed: The declawed of this CatAllOf. # noqa: E501
:type: bool
:type declawed: bool
"""
self._declawed = declawed

4
samples/client/petstore/python-asyncio/petstore_api/models/category.py
View File

@ -72,7 +72,7 @@ class Category(object):
:param id: The id of this Category. # noqa: E501
:type: int
:type id: int
"""
self._id = id
@ -93,7 +93,7 @@ class Category(object):
:param name: The name of this Category. # noqa: E501
:type: str
:type name: str
"""
if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501
raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501

2
samples/client/petstore/python-asyncio/petstore_api/models/class_model.py
View File

@ -68,7 +68,7 @@ class ClassModel(object):
:param _class: The _class of this ClassModel. # noqa: E501
:type: str
:type _class: str
"""
self.__class = _class

2
samples/client/petstore/python-asyncio/petstore_api/models/client.py
View File

@ -68,7 +68,7 @@ class Client(object):
:param client: The client of this Client. # noqa: E501
:type: str
:type client: str
"""
self._client = client

2
samples/client/petstore/python-asyncio/petstore_api/models/dog.py
View File

@ -68,7 +68,7 @@ class Dog(object):
:param breed: The breed of this Dog. # noqa: E501
:type: str
:type breed: str
"""
self._breed = breed

2
samples/client/petstore/python-asyncio/petstore_api/models/dog_all_of.py
View File

@ -68,7 +68,7 @@ class DogAllOf(object):
:param breed: The breed of this DogAllOf. # noqa: E501
:type: str
:type breed: str
"""
self._breed = breed

4
samples/client/petstore/python-asyncio/petstore_api/models/enum_arrays.py
View File

@ -73,7 +73,7 @@ class EnumArrays(object):
:param just_symbol: The just_symbol of this EnumArrays. # noqa: E501
:type: str
:type just_symbol: str
"""
allowed_values = [">=", "$"] # noqa: E501
if self.local_vars_configuration.client_side_validation and just_symbol not in allowed_values: # noqa: E501
@ -100,7 +100,7 @@ class EnumArrays(object):
:param array_enum: The array_enum of this EnumArrays. # noqa: E501
:type: list[str]
:type array_enum: list[str]
"""
allowed_values = ["fish", "crab"] # noqa: E501
if (self.local_vars_configuration.client_side_validation and

10
samples/client/petstore/python-asyncio/petstore_api/models/enum_test.py
View File

@ -87,7 +87,7 @@ class EnumTest(object):
:param enum_string: The enum_string of this EnumTest. # noqa: E501
:type: str
:type enum_string: str
"""
allowed_values = ["UPPER", "lower", ""] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_string not in allowed_values: # noqa: E501
@ -114,7 +114,7 @@ class EnumTest(object):
:param enum_string_required: The enum_string_required of this EnumTest. # noqa: E501
:type: str
:type enum_string_required: str
"""
if self.local_vars_configuration.client_side_validation and enum_string_required is None: # noqa: E501
raise ValueError("Invalid value for `enum_string_required`, must not be `None`") # noqa: E501
@ -143,7 +143,7 @@ class EnumTest(object):
:param enum_integer: The enum_integer of this EnumTest. # noqa: E501
:type: int
:type enum_integer: int
"""
allowed_values = [1, -1] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_integer not in allowed_values: # noqa: E501
@ -170,7 +170,7 @@ class EnumTest(object):
:param enum_number: The enum_number of this EnumTest. # noqa: E501
:type: float
:type enum_number: float
"""
allowed_values = [1.1, -1.2] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_number not in allowed_values: # noqa: E501
@ -197,7 +197,7 @@ class EnumTest(object):
:param outer_enum: The outer_enum of this EnumTest. # noqa: E501
:type: OuterEnum
:type outer_enum: OuterEnum
"""
self._outer_enum = outer_enum

2
samples/client/petstore/python-asyncio/petstore_api/models/file.py
View File

@ -70,7 +70,7 @@ class File(object):
Test capitalization # noqa: E501
:param source_uri: The source_uri of this File. # noqa: E501
:type: str
:type source_uri: str
"""
self._source_uri = source_uri

4
samples/client/petstore/python-asyncio/petstore_api/models/file_schema_test_class.py
View File

@ -73,7 +73,7 @@ class FileSchemaTestClass(object):
:param file: The file of this FileSchemaTestClass. # noqa: E501
:type: File
:type file: File
"""
self._file = file
@ -94,7 +94,7 @@ class FileSchemaTestClass(object):
:param files: The files of this FileSchemaTestClass. # noqa: E501
:type: list[File]
:type files: list[File]
"""
self._files = files

28
samples/client/petstore/python-asyncio/petstore_api/models/format_test.py
View File

@ -129,7 +129,7 @@ class FormatTest(object):
:param integer: The integer of this FormatTest. # noqa: E501
:type: int
:type integer: int
"""
if (self.local_vars_configuration.client_side_validation and
integer is not None and integer > 100): # noqa: E501
@ -156,7 +156,7 @@ class FormatTest(object):
:param int32: The int32 of this FormatTest. # noqa: E501
:type: int
:type int32: int
"""
if (self.local_vars_configuration.client_side_validation and
int32 is not None and int32 > 200): # noqa: E501
@ -183,7 +183,7 @@ class FormatTest(object):
:param int64: The int64 of this FormatTest. # noqa: E501
:type: int
:type int64: int
"""
self._int64 = int64
@ -204,7 +204,7 @@ class FormatTest(object):
:param number: The number of this FormatTest. # noqa: E501
:type: float
:type number: float
"""
if self.local_vars_configuration.client_side_validation and number is None: # noqa: E501
raise ValueError("Invalid value for `number`, must not be `None`") # noqa: E501
@ -233,7 +233,7 @@ class FormatTest(object):
:param float: The float of this FormatTest. # noqa: E501
:type: float
:type float: float
"""
if (self.local_vars_configuration.client_side_validation and
float is not None and float > 987.6): # noqa: E501
@ -260,7 +260,7 @@ class FormatTest(object):
:param double: The double of this FormatTest. # noqa: E501
:type: float
:type double: float
"""
if (self.local_vars_configuration.client_side_validation and
double is not None and double > 123.4): # noqa: E501
@ -287,7 +287,7 @@ class FormatTest(object):
:param string: The string of this FormatTest. # noqa: E501
:type: str
:type string: str
"""
if (self.local_vars_configuration.client_side_validation and
string is not None and not re.search(r'[a-z]', string, flags=re.IGNORECASE)): # noqa: E501
@ -311,7 +311,7 @@ class FormatTest(object):
:param byte: The byte of this FormatTest. # noqa: E501
:type: str
:type byte: str
"""
if self.local_vars_configuration.client_side_validation and byte is None: # noqa: E501
raise ValueError("Invalid value for `byte`, must not be `None`") # noqa: E501
@ -337,7 +337,7 @@ class FormatTest(object):
:param binary: The binary of this FormatTest. # noqa: E501
:type: file
:type binary: file
"""
self._binary = binary
@ -358,7 +358,7 @@ class FormatTest(object):
:param date: The date of this FormatTest. # noqa: E501
:type: date
:type date: date
"""
if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501
raise ValueError("Invalid value for `date`, must not be `None`") # noqa: E501
@ -381,7 +381,7 @@ class FormatTest(object):
:param date_time: The date_time of this FormatTest. # noqa: E501
:type: datetime
:type date_time: datetime
"""
self._date_time = date_time
@ -402,7 +402,7 @@ class FormatTest(object):
:param uuid: The uuid of this FormatTest. # noqa: E501
:type: str
:type uuid: str
"""
self._uuid = uuid
@ -423,7 +423,7 @@ class FormatTest(object):
:param password: The password of this FormatTest. # noqa: E501
:type: str
:type password: str
"""
if self.local_vars_configuration.client_side_validation and password is None: # noqa: E501
raise ValueError("Invalid value for `password`, must not be `None`") # noqa: E501
@ -452,7 +452,7 @@ class FormatTest(object):
:param big_decimal: The big_decimal of this FormatTest. # noqa: E501
:type: BigDecimal
:type big_decimal: BigDecimal
"""
self._big_decimal = big_decimal

4
samples/client/petstore/python-asyncio/petstore_api/models/has_only_read_only.py
View File

@ -73,7 +73,7 @@ class HasOnlyReadOnly(object):
:param bar: The bar of this HasOnlyReadOnly. # noqa: E501
:type: str
:type bar: str
"""
self._bar = bar
@ -94,7 +94,7 @@ class HasOnlyReadOnly(object):
:param foo: The foo of this HasOnlyReadOnly. # noqa: E501
:type: str
:type foo: str
"""
self._foo = foo

2
samples/client/petstore/python-asyncio/petstore_api/models/list.py
View File

@ -68,7 +68,7 @@ class List(object):
:param _123_list: The _123_list of this List. # noqa: E501
:type: str
:type _123_list: str
"""
self.__123_list = _123_list

8
samples/client/petstore/python-asyncio/petstore_api/models/map_test.py
View File

@ -83,7 +83,7 @@ class MapTest(object):
:param map_map_of_string: The map_map_of_string of this MapTest. # noqa: E501
:type: dict(str, dict(str, str))
:type map_map_of_string: dict(str, dict(str, str))
"""
self._map_map_of_string = map_map_of_string
@ -104,7 +104,7 @@ class MapTest(object):
:param map_of_enum_string: The map_of_enum_string of this MapTest. # noqa: E501
:type: dict(str, str)
:type map_of_enum_string: dict(str, str)
"""
allowed_values = ["UPPER", "lower"] # noqa: E501
if (self.local_vars_configuration.client_side_validation and
@ -133,7 +133,7 @@ class MapTest(object):
:param direct_map: The direct_map of this MapTest. # noqa: E501
:type: dict(str, bool)
:type direct_map: dict(str, bool)
"""
self._direct_map = direct_map
@ -154,7 +154,7 @@ class MapTest(object):
:param indirect_map: The indirect_map of this MapTest. # noqa: E501
:type: dict(str, bool)
:type indirect_map: dict(str, bool)
"""
self._indirect_map = indirect_map

6
samples/client/petstore/python-asyncio/petstore_api/models/mixed_properties_and_additional_properties_class.py
View File

@ -78,7 +78,7 @@ class MixedPropertiesAndAdditionalPropertiesClass(object):
:param uuid: The uuid of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501
:type: str
:type uuid: str
"""
self._uuid = uuid
@ -99,7 +99,7 @@ class MixedPropertiesAndAdditionalPropertiesClass(object):
:param date_time: The date_time of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501
:type: datetime
:type date_time: datetime
"""
self._date_time = date_time
@ -120,7 +120,7 @@ class MixedPropertiesAndAdditionalPropertiesClass(object):
:param map: The map of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501
:type: dict(str, Animal)
:type map: dict(str, Animal)
"""
self._map = map

4
samples/client/petstore/python-asyncio/petstore_api/models/model200_response.py
View File

@ -73,7 +73,7 @@ class Model200Response(object):
:param name: The name of this Model200Response. # noqa: E501
:type: int
:type name: int
"""
self._name = name
@ -94,7 +94,7 @@ class Model200Response(object):
:param _class: The _class of this Model200Response. # noqa: E501
:type: str
:type _class: str
"""
self.__class = _class

2
samples/client/petstore/python-asyncio/petstore_api/models/model_return.py
View File

@ -68,7 +68,7 @@ class ModelReturn(object):
:param _return: The _return of this ModelReturn. # noqa: E501
:type: int
:type _return: int
"""
self.__return = _return

8
samples/client/petstore/python-asyncio/petstore_api/models/name.py
View File

@ -82,7 +82,7 @@ class Name(object):
:param name: The name of this Name. # noqa: E501
:type: int
:type name: int
"""
if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501
raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501
@ -105,7 +105,7 @@ class Name(object):
:param snake_case: The snake_case of this Name. # noqa: E501
:type: int
:type snake_case: int
"""
self._snake_case = snake_case
@ -126,7 +126,7 @@ class Name(object):
:param _property: The _property of this Name. # noqa: E501
:type: str
:type _property: str
"""
self.__property = _property
@ -147,7 +147,7 @@ class Name(object):
:param _123_number: The _123_number of this Name. # noqa: E501
:type: int
:type _123_number: int
"""
self.__123_number = _123_number

2
samples/client/petstore/python-asyncio/petstore_api/models/number_only.py
View File

@ -68,7 +68,7 @@ class NumberOnly(object):
:param just_number: The just_number of this NumberOnly. # noqa: E501
:type: float
:type just_number: float
"""
self._just_number = just_number

12
samples/client/petstore/python-asyncio/petstore_api/models/order.py
View File

@ -93,7 +93,7 @@ class Order(object):
:param id: The id of this Order. # noqa: E501
:type: int
:type id: int
"""
self._id = id
@ -114,7 +114,7 @@ class Order(object):
:param pet_id: The pet_id of this Order. # noqa: E501
:type: int
:type pet_id: int
"""
self._pet_id = pet_id
@ -135,7 +135,7 @@ class Order(object):
:param quantity: The quantity of this Order. # noqa: E501
:type: int
:type quantity: int
"""
self._quantity = quantity
@ -156,7 +156,7 @@ class Order(object):
:param ship_date: The ship_date of this Order. # noqa: E501
:type: datetime
:type ship_date: datetime
"""
self._ship_date = ship_date
@ -179,7 +179,7 @@ class Order(object):
Order Status # noqa: E501
:param status: The status of this Order. # noqa: E501
:type: str
:type status: str
"""
allowed_values = ["placed", "approved", "delivered"] # noqa: E501
if self.local_vars_configuration.client_side_validation and status not in allowed_values: # noqa: E501
@ -206,7 +206,7 @@ class Order(object):
:param complete: The complete of this Order. # noqa: E501
:type: bool
:type complete: bool
"""
self._complete = complete

6
samples/client/petstore/python-asyncio/petstore_api/models/outer_composite.py
View File

@ -78,7 +78,7 @@ class OuterComposite(object):
:param my_number: The my_number of this OuterComposite. # noqa: E501
:type: float
:type my_number: float
"""
self._my_number = my_number
@ -99,7 +99,7 @@ class OuterComposite(object):
:param my_string: The my_string of this OuterComposite. # noqa: E501
:type: str
:type my_string: str
"""
self._my_string = my_string
@ -120,7 +120,7 @@ class OuterComposite(object):
:param my_boolean: The my_boolean of this OuterComposite. # noqa: E501
:type: bool
:type my_boolean: bool
"""
self._my_boolean = my_boolean

12
samples/client/petstore/python-asyncio/petstore_api/models/pet.py
View File

@ -91,7 +91,7 @@ class Pet(object):
:param id: The id of this Pet. # noqa: E501
:type: int
:type id: int
"""
self._id = id
@ -112,7 +112,7 @@ class Pet(object):
:param category: The category of this Pet. # noqa: E501
:type: Category
:type category: Category
"""
self._category = category
@ -133,7 +133,7 @@ class Pet(object):
:param name: The name of this Pet. # noqa: E501
:type: str
:type name: str
"""
if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501
raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501
@ -156,7 +156,7 @@ class Pet(object):
:param photo_urls: The photo_urls of this Pet. # noqa: E501
:type: list[str]
:type photo_urls: list[str]
"""
if self.local_vars_configuration.client_side_validation and photo_urls is None: # noqa: E501
raise ValueError("Invalid value for `photo_urls`, must not be `None`") # noqa: E501
@ -179,7 +179,7 @@ class Pet(object):
:param tags: The tags of this Pet. # noqa: E501
:type: list[Tag]
:type tags: list[Tag]
"""
self._tags = tags
@ -202,7 +202,7 @@ class Pet(object):
pet status in the store # noqa: E501
:param status: The status of this Pet. # noqa: E501
:type: str
:type status: str
"""
allowed_values = ["available", "pending", "sold"] # noqa: E501
if self.local_vars_configuration.client_side_validation and status not in allowed_values: # noqa: E501

4
samples/client/petstore/python-asyncio/petstore_api/models/read_only_first.py
View File

@ -73,7 +73,7 @@ class ReadOnlyFirst(object):
:param bar: The bar of this ReadOnlyFirst. # noqa: E501
:type: str
:type bar: str
"""
self._bar = bar
@ -94,7 +94,7 @@ class ReadOnlyFirst(object):
:param baz: The baz of this ReadOnlyFirst. # noqa: E501
:type: str
:type baz: str
"""
self._baz = baz

2
samples/client/petstore/python-asyncio/petstore_api/models/special_model_name.py
View File

@ -68,7 +68,7 @@ class SpecialModelName(object):
:param special_property_name: The special_property_name of this SpecialModelName. # noqa: E501
:type: int
:type special_property_name: int
"""
self._special_property_name = special_property_name

4
samples/client/petstore/python-asyncio/petstore_api/models/tag.py
View File

@ -73,7 +73,7 @@ class Tag(object):
:param id: The id of this Tag. # noqa: E501
:type: int
:type id: int
"""
self._id = id
@ -94,7 +94,7 @@ class Tag(object):
:param name: The name of this Tag. # noqa: E501
:type: str
:type name: str
"""
self._name = name

10
samples/client/petstore/python-asyncio/petstore_api/models/type_holder_default.py
View File

@ -83,7 +83,7 @@ class TypeHolderDefault(object):
:param string_item: The string_item of this TypeHolderDefault. # noqa: E501
:type: str
:type string_item: str
"""
if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501
raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501
@ -106,7 +106,7 @@ class TypeHolderDefault(object):
:param number_item: The number_item of this TypeHolderDefault. # noqa: E501
:type: float
:type number_item: float
"""
if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501
raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501
@ -129,7 +129,7 @@ class TypeHolderDefault(object):
:param integer_item: The integer_item of this TypeHolderDefault. # noqa: E501
:type: int
:type integer_item: int
"""
if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501
raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501
@ -152,7 +152,7 @@ class TypeHolderDefault(object):
:param bool_item: The bool_item of this TypeHolderDefault. # noqa: E501
:type: bool
:type bool_item: bool
"""
if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501
raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501
@ -175,7 +175,7 @@ class TypeHolderDefault(object):
:param array_item: The array_item of this TypeHolderDefault. # noqa: E501
:type: list[int]
:type array_item: list[int]
"""
if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501
raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501

12
samples/client/petstore/python-asyncio/petstore_api/models/type_holder_example.py
View File

@ -87,7 +87,7 @@ class TypeHolderExample(object):
:param string_item: The string_item of this TypeHolderExample. # noqa: E501
:type: str
:type string_item: str
"""
if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501
raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501
@ -110,7 +110,7 @@ class TypeHolderExample(object):
:param number_item: The number_item of this TypeHolderExample. # noqa: E501
:type: float
:type number_item: float
"""
if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501
raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501
@ -133,7 +133,7 @@ class TypeHolderExample(object):
:param float_item: The float_item of this TypeHolderExample. # noqa: E501
:type: float
:type float_item: float
"""
if self.local_vars_configuration.client_side_validation and float_item is None: # noqa: E501
raise ValueError("Invalid value for `float_item`, must not be `None`") # noqa: E501
@ -156,7 +156,7 @@ class TypeHolderExample(object):
:param integer_item: The integer_item of this TypeHolderExample. # noqa: E501
:type: int
:type integer_item: int
"""
if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501
raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501
@ -179,7 +179,7 @@ class TypeHolderExample(object):
:param bool_item: The bool_item of this TypeHolderExample. # noqa: E501
:type: bool
:type bool_item: bool
"""
if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501
raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501
@ -202,7 +202,7 @@ class TypeHolderExample(object):
:param array_item: The array_item of this TypeHolderExample. # noqa: E501
:type: list[int]
:type array_item: list[int]
"""
if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501
raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501

16
samples/client/petstore/python-asyncio/petstore_api/models/user.py
View File

@ -103,7 +103,7 @@ class User(object):
:param id: The id of this User. # noqa: E501
:type: int
:type id: int
"""
self._id = id
@ -124,7 +124,7 @@ class User(object):
:param username: The username of this User. # noqa: E501
:type: str
:type username: str
"""
self._username = username
@ -145,7 +145,7 @@ class User(object):
:param first_name: The first_name of this User. # noqa: E501
:type: str
:type first_name: str
"""
self._first_name = first_name
@ -166,7 +166,7 @@ class User(object):
:param last_name: The last_name of this User. # noqa: E501
:type: str
:type last_name: str
"""
self._last_name = last_name
@ -187,7 +187,7 @@ class User(object):
:param email: The email of this User. # noqa: E501
:type: str
:type email: str
"""
self._email = email
@ -208,7 +208,7 @@ class User(object):
:param password: The password of this User. # noqa: E501
:type: str
:type password: str
"""
self._password = password
@ -229,7 +229,7 @@ class User(object):
:param phone: The phone of this User. # noqa: E501
:type: str
:type phone: str
"""
self._phone = phone
@ -252,7 +252,7 @@ class User(object):
User Status # noqa: E501
:param user_status: The user_status of this User. # noqa: E501
:type: int
:type user_status: int
"""
self._user_status = user_status

58
samples/client/petstore/python-asyncio/petstore_api/models/xml_item.py
View File

@ -208,7 +208,7 @@ class XmlItem(object):
:param attribute_string: The attribute_string of this XmlItem. # noqa: E501
:type: str
:type attribute_string: str
"""
self._attribute_string = attribute_string
@ -229,7 +229,7 @@ class XmlItem(object):
:param attribute_number: The attribute_number of this XmlItem. # noqa: E501
:type: float
:type attribute_number: float
"""
self._attribute_number = attribute_number
@ -250,7 +250,7 @@ class XmlItem(object):
:param attribute_integer: The attribute_integer of this XmlItem. # noqa: E501
:type: int
:type attribute_integer: int
"""
self._attribute_integer = attribute_integer
@ -271,7 +271,7 @@ class XmlItem(object):
:param attribute_boolean: The attribute_boolean of this XmlItem. # noqa: E501
:type: bool
:type attribute_boolean: bool
"""
self._attribute_boolean = attribute_boolean
@ -292,7 +292,7 @@ class XmlItem(object):
:param wrapped_array: The wrapped_array of this XmlItem. # noqa: E501
:type: list[int]
:type wrapped_array: list[int]
"""
self._wrapped_array = wrapped_array
@ -313,7 +313,7 @@ class XmlItem(object):
:param name_string: The name_string of this XmlItem. # noqa: E501
:type: str
:type name_string: str
"""
self._name_string = name_string
@ -334,7 +334,7 @@ class XmlItem(object):
:param name_number: The name_number of this XmlItem. # noqa: E501
:type: float
:type name_number: float
"""
self._name_number = name_number
@ -355,7 +355,7 @@ class XmlItem(object):
:param name_integer: The name_integer of this XmlItem. # noqa: E501
:type: int
:type name_integer: int
"""
self._name_integer = name_integer
@ -376,7 +376,7 @@ class XmlItem(object):
:param name_boolean: The name_boolean of this XmlItem. # noqa: E501
:type: bool
:type name_boolean: bool
"""
self._name_boolean = name_boolean
@ -397,7 +397,7 @@ class XmlItem(object):
:param name_array: The name_array of this XmlItem. # noqa: E501
:type: list[int]
:type name_array: list[int]
"""
self._name_array = name_array
@ -418,7 +418,7 @@ class XmlItem(object):
:param name_wrapped_array: The name_wrapped_array of this XmlItem. # noqa: E501
:type: list[int]
:type name_wrapped_array: list[int]
"""
self._name_wrapped_array = name_wrapped_array
@ -439,7 +439,7 @@ class XmlItem(object):
:param prefix_string: The prefix_string of this XmlItem. # noqa: E501
:type: str
:type prefix_string: str
"""
self._prefix_string = prefix_string
@ -460,7 +460,7 @@ class XmlItem(object):
:param prefix_number: The prefix_number of this XmlItem. # noqa: E501
:type: float
:type prefix_number: float
"""
self._prefix_number = prefix_number
@ -481,7 +481,7 @@ class XmlItem(object):
:param prefix_integer: The prefix_integer of this XmlItem. # noqa: E501
:type: int
:type prefix_integer: int
"""
self._prefix_integer = prefix_integer
@ -502,7 +502,7 @@ class XmlItem(object):
:param prefix_boolean: The prefix_boolean of this XmlItem. # noqa: E501
:type: bool
:type prefix_boolean: bool
"""
self._prefix_boolean = prefix_boolean
@ -523,7 +523,7 @@ class XmlItem(object):
:param prefix_array: The prefix_array of this XmlItem. # noqa: E501
:type: list[int]
:type prefix_array: list[int]
"""
self._prefix_array = prefix_array
@ -544,7 +544,7 @@ class XmlItem(object):
:param prefix_wrapped_array: The prefix_wrapped_array of this XmlItem. # noqa: E501
:type: list[int]
:type prefix_wrapped_array: list[int]
"""
self._prefix_wrapped_array = prefix_wrapped_array
@ -565,7 +565,7 @@ class XmlItem(object):
:param namespace_string: The namespace_string of this XmlItem. # noqa: E501
:type: str
:type namespace_string: str
"""
self._namespace_string = namespace_string
@ -586,7 +586,7 @@ class XmlItem(object):
:param namespace_number: The namespace_number of this XmlItem. # noqa: E501
:type: float
:type namespace_number: float
"""
self._namespace_number = namespace_number
@ -607,7 +607,7 @@ class XmlItem(object):
:param namespace_integer: The namespace_integer of this XmlItem. # noqa: E501
:type: int
:type namespace_integer: int
"""
self._namespace_integer = namespace_integer
@ -628,7 +628,7 @@ class XmlItem(object):
:param namespace_boolean: The namespace_boolean of this XmlItem. # noqa: E501
:type: bool
:type namespace_boolean: bool
"""
self._namespace_boolean = namespace_boolean
@ -649,7 +649,7 @@ class XmlItem(object):
:param namespace_array: The namespace_array of this XmlItem. # noqa: E501
:type: list[int]
:type namespace_array: list[int]
"""
self._namespace_array = namespace_array
@ -670,7 +670,7 @@ class XmlItem(object):
:param namespace_wrapped_array: The namespace_wrapped_array of this XmlItem. # noqa: E501
:type: list[int]
:type namespace_wrapped_array: list[int]
"""
self._namespace_wrapped_array = namespace_wrapped_array
@ -691,7 +691,7 @@ class XmlItem(object):
:param prefix_ns_string: The prefix_ns_string of this XmlItem. # noqa: E501
:type: str
:type prefix_ns_string: str
"""
self._prefix_ns_string = prefix_ns_string
@ -712,7 +712,7 @@ class XmlItem(object):
:param prefix_ns_number: The prefix_ns_number of this XmlItem. # noqa: E501
:type: float
:type prefix_ns_number: float
"""
self._prefix_ns_number = prefix_ns_number
@ -733,7 +733,7 @@ class XmlItem(object):
:param prefix_ns_integer: The prefix_ns_integer of this XmlItem. # noqa: E501
:type: int
:type prefix_ns_integer: int
"""
self._prefix_ns_integer = prefix_ns_integer
@ -754,7 +754,7 @@ class XmlItem(object):
:param prefix_ns_boolean: The prefix_ns_boolean of this XmlItem. # noqa: E501
:type: bool
:type prefix_ns_boolean: bool
"""
self._prefix_ns_boolean = prefix_ns_boolean
@ -775,7 +775,7 @@ class XmlItem(object):
:param prefix_ns_array: The prefix_ns_array of this XmlItem. # noqa: E501
:type: list[int]
:type prefix_ns_array: list[int]
"""
self._prefix_ns_array = prefix_ns_array
@ -796,7 +796,7 @@ class XmlItem(object):
:param prefix_ns_wrapped_array: The prefix_ns_wrapped_array of this XmlItem. # noqa: E501
:type: list[int]
:type prefix_ns_wrapped_array: list[int]
"""
self._prefix_ns_wrapped_array = prefix_ns_wrapped_array

1
samples/client/petstore/python-experimental/petstore_api/api/another_fake_api.py
View File

@ -59,6 +59,7 @@ class AnotherFakeApi(object):
To test special tags and operation ID starting with number # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.call_123_test_special_tags(body, async_req=True)
>>> result = thread.get()

15
samples/client/petstore/python-experimental/petstore_api/api/fake_api.py
View File

@ -65,6 +65,7 @@ class FakeApi(object):
this route creates an XmlItem # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_xml_item(xml_item, async_req=True)
>>> result = thread.get()
@ -184,6 +185,7 @@ class FakeApi(object):
Test serialization of outer boolean types # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fake_outer_boolean_serialize(async_req=True)
>>> result = thread.get()
@ -293,6 +295,7 @@ class FakeApi(object):
Test serialization of object with outer number type # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fake_outer_composite_serialize(async_req=True)
>>> result = thread.get()
@ -402,6 +405,7 @@ class FakeApi(object):
Test serialization of outer enum # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fake_outer_enum_serialize(async_req=True)
>>> result = thread.get()
@ -511,6 +515,7 @@ class FakeApi(object):
Test serialization of outer number types # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fake_outer_number_serialize(async_req=True)
>>> result = thread.get()
@ -620,6 +625,7 @@ class FakeApi(object):
Test serialization of outer string types # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.fake_outer_string_serialize(async_req=True)
>>> result = thread.get()
@ -730,6 +736,7 @@ class FakeApi(object):
For this test, the body for this request much reference a schema named `File`. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_body_with_file_schema(body, async_req=True)
>>> result = thread.get()
@ -845,6 +852,7 @@ class FakeApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_body_with_query_params(query, body, async_req=True)
>>> result = thread.get()
@ -969,6 +977,7 @@ class FakeApi(object):
To test \"client\" model # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_client_model(body, async_req=True)
>>> result = thread.get()
@ -1090,6 +1099,7 @@ class FakeApi(object):
This route has required values with enums of 1 # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_endpoint_enums_length_one(query_integer=3, query_string='brillig', path_string='hello', path_integer=34, header_number=1.234, async_req=True)
>>> result = thread.get()
@ -1268,6 +1278,7 @@ class FakeApi(object):
Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True)
>>> result = thread.get()
@ -1521,6 +1532,7 @@ class FakeApi(object):
To test enum parameters # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_enum_parameters(async_req=True)
>>> result = thread.get()
@ -1730,6 +1742,7 @@ class FakeApi(object):
Fake endpoint to test group parameters (optional) # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True)
>>> result = thread.get()
@ -1879,6 +1892,7 @@ class FakeApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_inline_additional_properties(param, async_req=True)
>>> result = thread.get()
@ -1994,6 +2008,7 @@ class FakeApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_json_form_data(param, param2, async_req=True)
>>> result = thread.get()

1
samples/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py
View File

@ -59,6 +59,7 @@ class FakeClassnameTags123Api(object):
To test class name in snake case # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_classname(body, async_req=True)
>>> result = thread.get()

9
samples/client/petstore/python-experimental/petstore_api/api/pet_api.py
View File

@ -59,6 +59,7 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_pet(body, async_req=True)
>>> result = thread.get()
@ -176,6 +177,7 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_pet(pet_id, async_req=True)
>>> result = thread.get()
@ -298,6 +300,7 @@ class PetApi(object):
Multiple status values can be provided with comma separated strings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_status(status, async_req=True)
>>> result = thread.get()
@ -425,6 +428,7 @@ class PetApi(object):
Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_tags(tags, async_req=True)
>>> result = thread.get()
@ -545,6 +549,7 @@ class PetApi(object):
Returns a single pet # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_pet_by_id(pet_id, async_req=True)
>>> result = thread.get()
@ -663,6 +668,7 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet(body, async_req=True)
>>> result = thread.get()
@ -780,6 +786,7 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_form(pet_id, async_req=True)
>>> result = thread.get()
@ -909,6 +916,7 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file(pet_id, async_req=True)
>>> result = thread.get()
@ -1048,6 +1056,7 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_required_file(pet_id, required_file, async_req=True)
>>> result = thread.get()

4
samples/client/petstore/python-experimental/petstore_api/api/store_api.py
View File

@ -59,6 +59,7 @@ class StoreApi(object):
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_order(order_id, async_req=True)
>>> result = thread.get()
@ -172,6 +173,7 @@ class StoreApi(object):
Returns a map of status codes to quantities # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inventory(async_req=True)
>>> result = thread.get()
@ -279,6 +281,7 @@ class StoreApi(object):
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_order_by_id(order_id, async_req=True)
>>> result = thread.get()
@ -401,6 +404,7 @@ class StoreApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.place_order(body, async_req=True)
>>> result = thread.get()

8
samples/client/petstore/python-experimental/petstore_api/api/user_api.py
View File

@ -59,6 +59,7 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_user(body, async_req=True)
>>> result = thread.get()
@ -171,6 +172,7 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_array_input(body, async_req=True)
>>> result = thread.get()
@ -283,6 +285,7 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_list_input(body, async_req=True)
>>> result = thread.get()
@ -396,6 +399,7 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_user(username, async_req=True)
>>> result = thread.get()
@ -509,6 +513,7 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_by_name(username, async_req=True)
>>> result = thread.get()
@ -626,6 +631,7 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_user(username, password, async_req=True)
>>> result = thread.get()
@ -750,6 +756,7 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_user(async_req=True)
>>> result = thread.get()
@ -854,6 +861,7 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_user(username, body, async_req=True)
>>> result = thread.get()

15
samples/client/petstore/python-experimental/petstore_api/api_client.py
View File

@ -279,6 +279,7 @@ class ApiClient(object):
({str: (bool, str, int, float, date, datetime, str, none_type)},)
:param _check_type: boolean, whether to check the types of the data
received from the server
:type _check_type: bool
:return: deserialized object.
"""
@ -338,22 +339,28 @@ class ApiClient(object):
(float, none_type)
([int, none_type],)
({str: (bool, str, int, float, date, datetime, str, none_type)},)
:param files dict: key -> field name, value -> a list of open file
:param files: key -> field name, value -> a list of open file
objects for `multipart/form-data`.
:type files: dict
:param async_req bool: execute request asynchronously
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param collection_formats: dict of collection formats for path, query,
header, and post parameters.
:type collection_formats: dict, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:param _check_type: boolean describing if the data back from the server
should have its type checked.
:type _check_type: bool, optional
:return:
If async_req parameter is True,
the request will be called asynchronously.
@ -547,9 +554,9 @@ class ApiClient(object):
:param headers: Header parameters dict to be updated.
:param querys: Query parameters tuple list to be updated.
:param auth_settings: Authentication setting identifiers list.
:resource_path: A string representation of the HTTP request resource path.
:method: A string representation of the HTTP request method.
:body: A object representing the body of the HTTP request.
:param resource_path: A string representation of the HTTP request resource path.
:param method: A string representation of the HTTP request method.
:param body: A object representing the body of the HTTP request.
The object type is the return value of sanitize_for_serialization().
"""
if not auth_settings:

23
samples/client/petstore/python-tornado/petstore_api/api/another_fake_api.py
View File

@ -42,21 +42,26 @@ class AnotherFakeApi(object):
To test special tags and operation ID starting with number # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.call_123_test_special_tags(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Client
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Client
"""
kwargs['_return_http_data_only'] = True
return self.call_123_test_special_tags_with_http_info(body, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class AnotherFakeApi(object):
To test special tags and operation ID starting with number # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.call_123_test_special_tags_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Client, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

508
samples/client/petstore/python-tornado/petstore_api/api/fake_api.py
View File

File diff suppressed because it is too large Load Diff

23
samples/client/petstore/python-tornado/petstore_api/api/fake_classname_tags_123_api.py
View File

@ -42,21 +42,26 @@ class FakeClassnameTags123Api(object):
To test class name in snake case # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_classname(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Client
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Client
"""
kwargs['_return_http_data_only'] = True
return self.test_classname_with_http_info(body, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class FakeClassnameTags123Api(object):
To test class name in snake case # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.test_classname_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client body: client model (required)
:param body: client model (required)
:type body: Client
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Client, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

249
samples/client/petstore/python-tornado/petstore_api/api/pet_api.py
View File

@ -41,21 +41,26 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_pet(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.add_pet_with_http_info(body, **kwargs) # noqa: E501
@ -65,23 +70,29 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.add_pet_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -153,22 +164,28 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_pet(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: Pet id to delete (required)
:param str api_key:
:param pet_id: Pet id to delete (required)
:type pet_id: int
:param api_key:
:type api_key: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.delete_pet_with_http_info(pet_id, **kwargs) # noqa: E501
@ -178,24 +195,31 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_pet_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: Pet id to delete (required)
:param str api_key:
:param pet_id: Pet id to delete (required)
:type pet_id: int
:param api_key:
:type api_key: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -267,21 +291,26 @@ class PetApi(object):
Multiple status values can be provided with comma separated strings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_status(status, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] status: Status values that need to be considered for filter (required)
:param status: Status values that need to be considered for filter (required)
:type status: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: list[Pet]
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: list[Pet]
"""
kwargs['_return_http_data_only'] = True
return self.find_pets_by_status_with_http_info(status, **kwargs) # noqa: E501
@ -292,23 +321,29 @@ class PetApi(object):
Multiple status values can be provided with comma separated strings # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_status_with_http_info(status, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] status: Status values that need to be considered for filter (required)
:param status: Status values that need to be considered for filter (required)
:type status: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -382,21 +417,26 @@ class PetApi(object):
Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_tags(tags, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] tags: Tags to filter by (required)
:param tags: Tags to filter by (required)
:type tags: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: list[Pet]
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: list[Pet]
"""
kwargs['_return_http_data_only'] = True
return self.find_pets_by_tags_with_http_info(tags, **kwargs) # noqa: E501
@ -407,23 +447,29 @@ class PetApi(object):
Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.find_pets_by_tags_with_http_info(tags, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[str] tags: Tags to filter by (required)
:param tags: Tags to filter by (required)
:type tags: list[str]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -497,21 +543,26 @@ class PetApi(object):
Returns a single pet # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_pet_by_id(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to return (required)
:param pet_id: ID of pet to return (required)
:type pet_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Pet
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Pet
"""
kwargs['_return_http_data_only'] = True
return self.get_pet_by_id_with_http_info(pet_id, **kwargs) # noqa: E501
@ -522,23 +573,29 @@ class PetApi(object):
Returns a single pet # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_pet_by_id_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to return (required)
:param pet_id: ID of pet to return (required)
:type pet_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Pet, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Pet, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -610,21 +667,26 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.update_pet_with_http_info(body, **kwargs) # noqa: E501
@ -634,23 +696,29 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet body: Pet object that needs to be added to the store (required)
:param body: Pet object that needs to be added to the store (required)
:type body: Pet
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -722,23 +790,30 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_form(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet that needs to be updated (required)
:param str name: Updated name of the pet
:param str status: Updated status of the pet
:param pet_id: ID of pet that needs to be updated (required)
:type pet_id: int
:param name: Updated name of the pet
:type name: str
:param status: Updated status of the pet
:type status: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.update_pet_with_form_with_http_info(pet_id, **kwargs) # noqa: E501
@ -748,25 +823,33 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_pet_with_form_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet that needs to be updated (required)
:param str name: Updated name of the pet
:param str status: Updated status of the pet
:param pet_id: ID of pet that needs to be updated (required)
:type pet_id: int
:param name: Updated name of the pet
:type name: str
:param status: Updated status of the pet
:type status: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -844,23 +927,30 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param str additional_metadata: Additional data to pass to server
:param file file: file to upload
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param file: file to upload
:type file: file
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: ApiResponse
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: ApiResponse
"""
kwargs['_return_http_data_only'] = True
return self.upload_file_with_http_info(pet_id, **kwargs) # noqa: E501
@ -870,25 +960,33 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_http_info(pet_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param str additional_metadata: Additional data to pass to server
:param file file: file to upload
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param file: file to upload
:type file: file
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -970,23 +1068,30 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_required_file(pet_id, required_file, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param file required_file: file to upload (required)
:param str additional_metadata: Additional data to pass to server
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param required_file: file to upload (required)
:type required_file: file
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: ApiResponse
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: ApiResponse
"""
kwargs['_return_http_data_only'] = True
return self.upload_file_with_required_file_with_http_info(pet_id, required_file, **kwargs) # noqa: E501
@ -996,25 +1101,33 @@ class PetApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.upload_file_with_required_file_with_http_info(pet_id, required_file, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int pet_id: ID of pet to update (required)
:param file required_file: file to upload (required)
:param str additional_metadata: Additional data to pass to server
:param pet_id: ID of pet to update (required)
:type pet_id: int
:param required_file: file to upload (required)
:type required_file: file
:param additional_metadata: Additional data to pass to server
:type additional_metadata: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

86
samples/client/petstore/python-tornado/petstore_api/api/store_api.py
View File

@ -42,21 +42,26 @@ class StoreApi(object):
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_order(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str order_id: ID of the order that needs to be deleted (required)
:param order_id: ID of the order that needs to be deleted (required)
:type order_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.delete_order_with_http_info(order_id, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class StoreApi(object):
For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_order_with_http_info(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str order_id: ID of the order that needs to be deleted (required)
:param order_id: ID of the order that needs to be deleted (required)
:type order_id: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -152,20 +163,24 @@ class StoreApi(object):
Returns a map of status codes to quantities # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inventory(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: dict(str, int)
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: dict(str, int)
"""
kwargs['_return_http_data_only'] = True
return self.get_inventory_with_http_info(**kwargs) # noqa: E501
@ -176,22 +191,27 @@ class StoreApi(object):
Returns a map of status codes to quantities # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_inventory_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(dict(str, int), status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(dict(str, int), status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -257,21 +277,26 @@ class StoreApi(object):
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_order_by_id(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int order_id: ID of pet that needs to be fetched (required)
:param order_id: ID of pet that needs to be fetched (required)
:type order_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Order
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Order
"""
kwargs['_return_http_data_only'] = True
return self.get_order_by_id_with_http_info(order_id, **kwargs) # noqa: E501
@ -282,23 +307,29 @@ class StoreApi(object):
For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_order_by_id_with_http_info(order_id, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param int order_id: ID of pet that needs to be fetched (required)
:param order_id: ID of pet that needs to be fetched (required)
:type order_id: int
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Order, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -374,21 +405,26 @@ class StoreApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.place_order(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Order body: order placed for purchasing the pet (required)
:param body: order placed for purchasing the pet (required)
:type body: Order
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: Order
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: Order
"""
kwargs['_return_http_data_only'] = True
return self.place_order_with_http_info(body, **kwargs) # noqa: E501
@ -398,23 +434,29 @@ class StoreApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.place_order_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Order body: order placed for purchasing the pet (required)
:param body: order placed for purchasing the pet (required)
:type body: Order
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(Order, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

190
samples/client/petstore/python-tornado/petstore_api/api/user_api.py
View File

@ -42,21 +42,26 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_user(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param User body: Created user object (required)
:param body: Created user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.create_user_with_http_info(body, **kwargs) # noqa: E501
@ -67,23 +72,29 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_user_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param User body: Created user object (required)
:param body: Created user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -151,21 +162,26 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_array_input(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.create_users_with_array_input_with_http_info(body, **kwargs) # noqa: E501
@ -175,23 +191,29 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_array_input_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -259,21 +281,26 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_list_input(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.create_users_with_list_input_with_http_info(body, **kwargs) # noqa: E501
@ -283,23 +310,29 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.create_users_with_list_input_with_http_info(body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] body: List of user object (required)
:param body: List of user object (required)
:type body: list[User]
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -368,21 +401,26 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_user(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be deleted (required)
:param username: The name that needs to be deleted (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.delete_user_with_http_info(username, **kwargs) # noqa: E501
@ -393,23 +431,29 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.delete_user_with_http_info(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be deleted (required)
:param username: The name that needs to be deleted (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -477,21 +521,26 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_by_name(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be fetched. Use user1 for testing. (required)
:param username: The name that needs to be fetched. Use user1 for testing. (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: User
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: User
"""
kwargs['_return_http_data_only'] = True
return self.get_user_by_name_with_http_info(username, **kwargs) # noqa: E501
@ -501,23 +550,29 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.get_user_by_name_with_http_info(username, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The name that needs to be fetched. Use user1 for testing. (required)
:param username: The name that needs to be fetched. Use user1 for testing. (required)
:type username: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(User, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(User, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -589,22 +644,28 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_user(username, password, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The user name for login (required)
:param str password: The password for login in clear text (required)
:param username: The user name for login (required)
:type username: str
:param password: The password for login in clear text (required)
:type password: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: str
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: str
"""
kwargs['_return_http_data_only'] = True
return self.login_user_with_http_info(username, password, **kwargs) # noqa: E501
@ -614,24 +675,31 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.login_user_with_http_info(username, password, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: The user name for login (required)
:param str password: The password for login in clear text (required)
:param username: The user name for login (required)
:type username: str
:param password: The password for login in clear text (required)
:type password: str
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: tuple(str, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(str, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()
@ -710,20 +778,24 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_user(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.logout_user_with_http_info(**kwargs) # noqa: E501
@ -733,22 +805,27 @@ class UserApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.logout_user_with_http_info(async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()
@ -810,22 +887,28 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_user(username, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: name that need to be deleted (required)
:param User body: Updated user object (required)
:param username: name that need to be deleted (required)
:type username: str
:param body: Updated user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
kwargs['_return_http_data_only'] = True
return self.update_user_with_http_info(username, body, **kwargs) # noqa: E501
@ -836,24 +919,31 @@ class UserApi(object):
This can only be done by the logged in user. # noqa: E501
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.update_user_with_http_info(username, body, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param str username: name that need to be deleted (required)
:param User body: Updated user object (required)
:param username: name that need to be deleted (required)
:type username: str
:param body: Updated user object (required)
:type body: User
:param async_req: Whether to execute the request asynchronously.
:type async_req: bool, optional
:param _return_http_data_only: response data without head status code
and headers
:type _return_http_data_only: bool, optional
:param _preload_content: if False, the urllib3.HTTPResponse object will
be returned without reading/decoding response
data. Default is True.
:type _preload_content: bool, optional
:param _request_timeout: timeout setting for this request. If one
number provided, it will be total request
timeout. It can also be a pair (tuple) of
(connection, read) timeouts.
:return: None
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: None
"""
local_var_params = locals()

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_any_type.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesAnyType(object):
:param name: The name of this AdditionalPropertiesAnyType. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_array.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesArray(object):
:param name: The name of this AdditionalPropertiesArray. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_boolean.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesBoolean(object):
:param name: The name of this AdditionalPropertiesBoolean. # noqa: E501
:type: str
:type name: str
"""
self._name = name

22
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_class.py
View File

@ -118,7 +118,7 @@ class AdditionalPropertiesClass(object):
:param map_string: The map_string of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, str)
:type map_string: dict(str, str)
"""
self._map_string = map_string
@ -139,7 +139,7 @@ class AdditionalPropertiesClass(object):
:param map_number: The map_number of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, float)
:type map_number: dict(str, float)
"""
self._map_number = map_number
@ -160,7 +160,7 @@ class AdditionalPropertiesClass(object):
:param map_integer: The map_integer of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, int)
:type map_integer: dict(str, int)
"""
self._map_integer = map_integer
@ -181,7 +181,7 @@ class AdditionalPropertiesClass(object):
:param map_boolean: The map_boolean of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, bool)
:type map_boolean: dict(str, bool)
"""
self._map_boolean = map_boolean
@ -202,7 +202,7 @@ class AdditionalPropertiesClass(object):
:param map_array_integer: The map_array_integer of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, list[int])
:type map_array_integer: dict(str, list[int])
"""
self._map_array_integer = map_array_integer
@ -223,7 +223,7 @@ class AdditionalPropertiesClass(object):
:param map_array_anytype: The map_array_anytype of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, list[object])
:type map_array_anytype: dict(str, list[object])
"""
self._map_array_anytype = map_array_anytype
@ -244,7 +244,7 @@ class AdditionalPropertiesClass(object):
:param map_map_string: The map_map_string of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, dict(str, str))
:type map_map_string: dict(str, dict(str, str))
"""
self._map_map_string = map_map_string
@ -265,7 +265,7 @@ class AdditionalPropertiesClass(object):
:param map_map_anytype: The map_map_anytype of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, dict(str, object))
:type map_map_anytype: dict(str, dict(str, object))
"""
self._map_map_anytype = map_map_anytype
@ -286,7 +286,7 @@ class AdditionalPropertiesClass(object):
:param anytype_1: The anytype_1 of this AdditionalPropertiesClass. # noqa: E501
:type: object
:type anytype_1: object
"""
self._anytype_1 = anytype_1
@ -307,7 +307,7 @@ class AdditionalPropertiesClass(object):
:param anytype_2: The anytype_2 of this AdditionalPropertiesClass. # noqa: E501
:type: object
:type anytype_2: object
"""
self._anytype_2 = anytype_2
@ -328,7 +328,7 @@ class AdditionalPropertiesClass(object):
:param anytype_3: The anytype_3 of this AdditionalPropertiesClass. # noqa: E501
:type: object
:type anytype_3: object
"""
self._anytype_3 = anytype_3

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_integer.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesInteger(object):
:param name: The name of this AdditionalPropertiesInteger. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_number.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesNumber(object):
:param name: The name of this AdditionalPropertiesNumber. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_object.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesObject(object):
:param name: The name of this AdditionalPropertiesObject. # noqa: E501
:type: str
:type name: str
"""
self._name = name

2
samples/client/petstore/python-tornado/petstore_api/models/additional_properties_string.py
View File

@ -68,7 +68,7 @@ class AdditionalPropertiesString(object):
:param name: The name of this AdditionalPropertiesString. # noqa: E501
:type: str
:type name: str
"""
self._name = name

4
samples/client/petstore/python-tornado/petstore_api/models/animal.py
View File

@ -78,7 +78,7 @@ class Animal(object):
:param class_name: The class_name of this Animal. # noqa: E501
:type: str
:type class_name: str
"""
if self.local_vars_configuration.client_side_validation and class_name is None: # noqa: E501
raise ValueError("Invalid value for `class_name`, must not be `None`") # noqa: E501
@ -101,7 +101,7 @@ class Animal(object):
:param color: The color of this Animal. # noqa: E501
:type: str
:type color: str
"""
self._color = color

6
samples/client/petstore/python-tornado/petstore_api/models/api_response.py
View File

@ -78,7 +78,7 @@ class ApiResponse(object):
:param code: The code of this ApiResponse. # noqa: E501
:type: int
:type code: int
"""
self._code = code
@ -99,7 +99,7 @@ class ApiResponse(object):
:param type: The type of this ApiResponse. # noqa: E501
:type: str
:type type: str
"""
self._type = type
@ -120,7 +120,7 @@ class ApiResponse(object):
:param message: The message of this ApiResponse. # noqa: E501
:type: str
:type message: str
"""
self._message = message

2
samples/client/petstore/python-tornado/petstore_api/models/array_of_array_of_number_only.py
View File

@ -68,7 +68,7 @@ class ArrayOfArrayOfNumberOnly(object):
:param array_array_number: The array_array_number of this ArrayOfArrayOfNumberOnly. # noqa: E501
:type: list[list[float]]
:type array_array_number: list[list[float]]
"""
self._array_array_number = array_array_number

2
samples/client/petstore/python-tornado/petstore_api/models/array_of_number_only.py
View File

@ -68,7 +68,7 @@ class ArrayOfNumberOnly(object):
:param array_number: The array_number of this ArrayOfNumberOnly. # noqa: E501
:type: list[float]
:type array_number: list[float]
"""
self._array_number = array_number

6
samples/client/petstore/python-tornado/petstore_api/models/array_test.py
View File

@ -78,7 +78,7 @@ class ArrayTest(object):
:param array_of_string: The array_of_string of this ArrayTest. # noqa: E501
:type: list[str]
:type array_of_string: list[str]
"""
self._array_of_string = array_of_string
@ -99,7 +99,7 @@ class ArrayTest(object):
:param array_array_of_integer: The array_array_of_integer of this ArrayTest. # noqa: E501
:type: list[list[int]]
:type array_array_of_integer: list[list[int]]
"""
self._array_array_of_integer = array_array_of_integer
@ -120,7 +120,7 @@ class ArrayTest(object):
:param array_array_of_model: The array_array_of_model of this ArrayTest. # noqa: E501
:type: list[list[ReadOnlyFirst]]
:type array_array_of_model: list[list[ReadOnlyFirst]]
"""
self._array_array_of_model = array_array_of_model

2
samples/client/petstore/python-tornado/petstore_api/models/big_cat.py
View File

@ -68,7 +68,7 @@ class BigCat(object):
:param kind: The kind of this BigCat. # noqa: E501
:type: str
:type kind: str
"""
allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501
if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501

2
samples/client/petstore/python-tornado/petstore_api/models/big_cat_all_of.py
View File

@ -68,7 +68,7 @@ class BigCatAllOf(object):
:param kind: The kind of this BigCatAllOf. # noqa: E501
:type: str
:type kind: str
"""
allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501
if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501

12
samples/client/petstore/python-tornado/petstore_api/models/capitalization.py
View File

@ -93,7 +93,7 @@ class Capitalization(object):
:param small_camel: The small_camel of this Capitalization. # noqa: E501
:type: str
:type small_camel: str
"""
self._small_camel = small_camel
@ -114,7 +114,7 @@ class Capitalization(object):
:param capital_camel: The capital_camel of this Capitalization. # noqa: E501
:type: str
:type capital_camel: str
"""
self._capital_camel = capital_camel
@ -135,7 +135,7 @@ class Capitalization(object):
:param small_snake: The small_snake of this Capitalization. # noqa: E501
:type: str
:type small_snake: str
"""
self._small_snake = small_snake
@ -156,7 +156,7 @@ class Capitalization(object):
:param capital_snake: The capital_snake of this Capitalization. # noqa: E501
:type: str
:type capital_snake: str
"""
self._capital_snake = capital_snake
@ -177,7 +177,7 @@ class Capitalization(object):
:param sca_eth_flow_points: The sca_eth_flow_points of this Capitalization. # noqa: E501
:type: str
:type sca_eth_flow_points: str
"""
self._sca_eth_flow_points = sca_eth_flow_points
@ -200,7 +200,7 @@ class Capitalization(object):
Name of the pet # noqa: E501
:param att_name: The att_name of this Capitalization. # noqa: E501
:type: str
:type att_name: str
"""
self._att_name = att_name

2
samples/client/petstore/python-tornado/petstore_api/models/cat.py
View File

@ -68,7 +68,7 @@ class Cat(object):
:param declawed: The declawed of this Cat. # noqa: E501
:type: bool
:type declawed: bool
"""
self._declawed = declawed

2
samples/client/petstore/python-tornado/petstore_api/models/cat_all_of.py
View File

@ -68,7 +68,7 @@ class CatAllOf(object):
:param declawed: The declawed of this CatAllOf. # noqa: E501
:type: bool
:type declawed: bool
"""
self._declawed = declawed

4
samples/client/petstore/python-tornado/petstore_api/models/category.py
View File

@ -72,7 +72,7 @@ class Category(object):
:param id: The id of this Category. # noqa: E501
:type: int
:type id: int
"""
self._id = id
@ -93,7 +93,7 @@ class Category(object):
:param name: The name of this Category. # noqa: E501
:type: str
:type name: str
"""
if self.local_vars_configuration.client_side_validation and name is None: # noqa: E501
raise ValueError("Invalid value for `name`, must not be `None`") # noqa: E501

2
samples/client/petstore/python-tornado/petstore_api/models/class_model.py
View File

@ -68,7 +68,7 @@ class ClassModel(object):
:param _class: The _class of this ClassModel. # noqa: E501
:type: str
:type _class: str
"""
self.__class = _class

2
samples/client/petstore/python-tornado/petstore_api/models/client.py
View File

@ -68,7 +68,7 @@ class Client(object):
:param client: The client of this Client. # noqa: E501
:type: str
:type client: str
"""
self._client = client

2
samples/client/petstore/python-tornado/petstore_api/models/dog.py
View File

@ -68,7 +68,7 @@ class Dog(object):
:param breed: The breed of this Dog. # noqa: E501
:type: str
:type breed: str
"""
self._breed = breed

2
samples/client/petstore/python-tornado/petstore_api/models/dog_all_of.py
View File

@ -68,7 +68,7 @@ class DogAllOf(object):
:param breed: The breed of this DogAllOf. # noqa: E501
:type: str
:type breed: str
"""
self._breed = breed

4
samples/client/petstore/python-tornado/petstore_api/models/enum_arrays.py
View File

@ -73,7 +73,7 @@ class EnumArrays(object):
:param just_symbol: The just_symbol of this EnumArrays. # noqa: E501
:type: str
:type just_symbol: str
"""
allowed_values = [">=", "$"] # noqa: E501
if self.local_vars_configuration.client_side_validation and just_symbol not in allowed_values: # noqa: E501
@ -100,7 +100,7 @@ class EnumArrays(object):
:param array_enum: The array_enum of this EnumArrays. # noqa: E501
:type: list[str]
:type array_enum: list[str]
"""
allowed_values = ["fish", "crab"] # noqa: E501
if (self.local_vars_configuration.client_side_validation and

10
samples/client/petstore/python-tornado/petstore_api/models/enum_test.py
View File

@ -87,7 +87,7 @@ class EnumTest(object):
:param enum_string: The enum_string of this EnumTest. # noqa: E501
:type: str
:type enum_string: str
"""
allowed_values = ["UPPER", "lower", ""] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_string not in allowed_values: # noqa: E501
@ -114,7 +114,7 @@ class EnumTest(object):
:param enum_string_required: The enum_string_required of this EnumTest. # noqa: E501
:type: str
:type enum_string_required: str
"""
if self.local_vars_configuration.client_side_validation and enum_string_required is None: # noqa: E501
raise ValueError("Invalid value for `enum_string_required`, must not be `None`") # noqa: E501
@ -143,7 +143,7 @@ class EnumTest(object):
:param enum_integer: The enum_integer of this EnumTest. # noqa: E501
:type: int
:type enum_integer: int
"""
allowed_values = [1, -1] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_integer not in allowed_values: # noqa: E501
@ -170,7 +170,7 @@ class EnumTest(object):
:param enum_number: The enum_number of this EnumTest. # noqa: E501
:type: float
:type enum_number: float
"""
allowed_values = [1.1, -1.2] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_number not in allowed_values: # noqa: E501
@ -197,7 +197,7 @@ class EnumTest(object):
:param outer_enum: The outer_enum of this EnumTest. # noqa: E501
:type: OuterEnum
:type outer_enum: OuterEnum
"""
self._outer_enum = outer_enum

2
samples/client/petstore/python-tornado/petstore_api/models/file.py
View File

@ -70,7 +70,7 @@ class File(object):
Test capitalization # noqa: E501
:param source_uri: The source_uri of this File. # noqa: E501
:type: str
:type source_uri: str
"""
self._source_uri = source_uri

4
samples/client/petstore/python-tornado/petstore_api/models/file_schema_test_class.py
View File

@ -73,7 +73,7 @@ class FileSchemaTestClass(object):
:param file: The file of this FileSchemaTestClass. # noqa: E501
:type: File
:type file: File
"""
self._file = file
@ -94,7 +94,7 @@ class FileSchemaTestClass(object):
:param files: The files of this FileSchemaTestClass. # noqa: E501
:type: list[File]
:type files: list[File]
"""
self._files = files

28
samples/client/petstore/python-tornado/petstore_api/models/format_test.py
View File

@ -129,7 +129,7 @@ class FormatTest(object):
:param integer: The integer of this FormatTest. # noqa: E501
:type: int
:type integer: int
"""
if (self.local_vars_configuration.client_side_validation and
integer is not None and integer > 100): # noqa: E501
@ -156,7 +156,7 @@ class FormatTest(object):
:param int32: The int32 of this FormatTest. # noqa: E501
:type: int
:type int32: int
"""
if (self.local_vars_configuration.client_side_validation and
int32 is not None and int32 > 200): # noqa: E501
@ -183,7 +183,7 @@ class FormatTest(object):
:param int64: The int64 of this FormatTest. # noqa: E501
:type: int
:type int64: int
"""
self._int64 = int64
@ -204,7 +204,7 @@ class FormatTest(object):
:param number: The number of this FormatTest. # noqa: E501
:type: float
:type number: float
"""
if self.local_vars_configuration.client_side_validation and number is None: # noqa: E501
raise ValueError("Invalid value for `number`, must not be `None`") # noqa: E501
@ -233,7 +233,7 @@ class FormatTest(object):
:param float: The float of this FormatTest. # noqa: E501
:type: float
:type float: float
"""
if (self.local_vars_configuration.client_side_validation and
float is not None and float > 987.6): # noqa: E501
@ -260,7 +260,7 @@ class FormatTest(object):
:param double: The double of this FormatTest. # noqa: E501
:type: float
:type double: float
"""
if (self.local_vars_configuration.client_side_validation and
double is not None and double > 123.4): # noqa: E501
@ -287,7 +287,7 @@ class FormatTest(object):
:param string: The string of this FormatTest. # noqa: E501
:type: str
:type string: str
"""
if (self.local_vars_configuration.client_side_validation and
string is not None and not re.search(r'[a-z]', string, flags=re.IGNORECASE)): # noqa: E501
@ -311,7 +311,7 @@ class FormatTest(object):
:param byte: The byte of this FormatTest. # noqa: E501
:type: str
:type byte: str
"""
if self.local_vars_configuration.client_side_validation and byte is None: # noqa: E501
raise ValueError("Invalid value for `byte`, must not be `None`") # noqa: E501
@ -337,7 +337,7 @@ class FormatTest(object):
:param binary: The binary of this FormatTest. # noqa: E501
:type: file
:type binary: file
"""
self._binary = binary
@ -358,7 +358,7 @@ class FormatTest(object):
:param date: The date of this FormatTest. # noqa: E501
:type: date
:type date: date
"""
if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501
raise ValueError("Invalid value for `date`, must not be `None`") # noqa: E501
@ -381,7 +381,7 @@ class FormatTest(object):
:param date_time: The date_time of this FormatTest. # noqa: E501
:type: datetime
:type date_time: datetime
"""
self._date_time = date_time
@ -402,7 +402,7 @@ class FormatTest(object):
:param uuid: The uuid of this FormatTest. # noqa: E501
:type: str
:type uuid: str
"""
self._uuid = uuid
@ -423,7 +423,7 @@ class FormatTest(object):
:param password: The password of this FormatTest. # noqa: E501
:type: str
:type password: str
"""
if self.local_vars_configuration.client_side_validation and password is None: # noqa: E501
raise ValueError("Invalid value for `password`, must not be `None`") # noqa: E501
@ -452,7 +452,7 @@ class FormatTest(object):
:param big_decimal: The big_decimal of this FormatTest. # noqa: E501
:type: BigDecimal
:type big_decimal: BigDecimal
"""
self._big_decimal = big_decimal

4
samples/client/petstore/python-tornado/petstore_api/models/has_only_read_only.py
View File

@ -73,7 +73,7 @@ class HasOnlyReadOnly(object):
:param bar: The bar of this HasOnlyReadOnly. # noqa: E501
:type: str
:type bar: str
"""
self._bar = bar
@ -94,7 +94,7 @@ class HasOnlyReadOnly(object):
:param foo: The foo of this HasOnlyReadOnly. # noqa: E501
:type: str
:type foo: str
"""
self._foo = foo

2
samples/client/petstore/python-tornado/petstore_api/models/list.py
View File

@ -68,7 +68,7 @@ class List(object):
:param _123_list: The _123_list of this List. # noqa: E501
:type: str
:type _123_list: str
"""
self.__123_list = _123_list

8
samples/client/petstore/python-tornado/petstore_api/models/map_test.py
View File

@ -83,7 +83,7 @@ class MapTest(object):
:param map_map_of_string: The map_map_of_string of this MapTest. # noqa: E501
:type: dict(str, dict(str, str))
:type map_map_of_string: dict(str, dict(str, str))
"""
self._map_map_of_string = map_map_of_string
@ -104,7 +104,7 @@ class MapTest(object):
:param map_of_enum_string: The map_of_enum_string of this MapTest. # noqa: E501
:type: dict(str, str)
:type map_of_enum_string: dict(str, str)
"""
allowed_values = ["UPPER", "lower"] # noqa: E501
if (self.local_vars_configuration.client_side_validation and
@ -133,7 +133,7 @@ class MapTest(object):
:param direct_map: The direct_map of this MapTest. # noqa: E501
:type: dict(str, bool)
:type direct_map: dict(str, bool)
"""
self._direct_map = direct_map
@ -154,7 +154,7 @@ class MapTest(object):
:param indirect_map: The indirect_map of this MapTest. # noqa: E501
:type: dict(str, bool)
:type indirect_map: dict(str, bool)
"""
self._indirect_map = indirect_map

Some files were not shown because too many files have changed in this diff Show More