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
240 changed files with 3920 additions and 1882 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
samples/client/petstore/python/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/petstore_api/api/fake_api.py
View File

File diff suppressed because it is too large Load Diff

23
samples/client/petstore/python/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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