loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-12-05 16:46:11 +00:00
Code Issues Packages Projects Releases Wiki 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/openapi3/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(client, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client client: client model (required)
:param client: client model (required)
:type client: 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(client, **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(client, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client client: client model (required)
:param client: client model (required)
:type client: 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()

17
samples/openapi3/client/petstore/python/petstore_api/api/default_api.py
View File

@@ -41,20 +41,24 @@ class DefaultApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.foo_get(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: InlineResponseDefault
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: InlineResponseDefault
"""
kwargs['_return_http_data_only'] = True
return self.foo_get_with_http_info(**kwargs) # noqa: E501
@@ -64,22 +68,27 @@ class DefaultApi(object):
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please pass async_req=True
>>> thread = api.foo_get_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(InlineResponseDefault, status_code(int), headers(HTTPHeaderDict))
:return: Returns the result object.
If the method is called asynchronously,
returns the request thread.
:rtype: tuple(InlineResponseDefault, status_code(int), headers(HTTPHeaderDict))
"""
local_var_params = locals()

537
samples/openapi3/client/petstore/python/petstore_api/api/fake_api.py
View File

File diff suppressed because it is too large Load Diff

23
samples/openapi3/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(client, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client client: client model (required)
:param client: client model (required)
:type client: 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(client, **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(client, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Client client: client model (required)
:param client: client model (required)
:type client: 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/openapi3/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(pet, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet pet: Pet object that needs to be added to the store (required)
:param pet: Pet object that needs to be added to the store (required)
:type pet: 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(pet, **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(pet, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet pet: Pet object that needs to be added to the store (required)
:param pet: Pet object that needs to be added to the store (required)
:type pet: 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_hosts = [
@@ -167,22 +178,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
@@ -192,24 +209,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()
@@ -281,21 +305,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
@@ -306,23 +335,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()
@@ -396,21 +431,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
@@ -421,23 +461,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()
@@ -511,21 +557,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
@@ -536,23 +587,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()
@@ -624,21 +681,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(pet, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet pet: Pet object that needs to be added to the store (required)
:param pet: Pet object that needs to be added to the store (required)
:type pet: 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(pet, **kwargs) # noqa: E501
@@ -648,23 +710,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(pet, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Pet pet: Pet object that needs to be added to the store (required)
:param pet: Pet object that needs to be added to the store (required)
:type pet: 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_hosts = [
@@ -750,23 +818,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
@@ -776,25 +851,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()
@@ -872,23 +955,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
@@ -898,25 +988,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()
@@ -998,23 +1096,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
@@ -1024,25 +1129,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/openapi3/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(order, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Order order: order placed for purchasing the pet (required)
:param order: order placed for purchasing the pet (required)
:type order: 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(order, **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(order, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param Order order: order placed for purchasing the pet (required)
:param order: order placed for purchasing the pet (required)
:type order: 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/openapi3/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(user, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param User user: Created user object (required)
:param user: Created user object (required)
:type user: 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(user, **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(user, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param User user: Created user object (required)
:param user: Created user object (required)
:type user: 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()
@@ -155,21 +166,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(user, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] user: List of user object (required)
:param user: List of user object (required)
:type user: 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(user, **kwargs) # noqa: E501
@@ -179,23 +195,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(user, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] user: List of user object (required)
:param user: List of user object (required)
:type user: 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()
@@ -267,21 +289,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(user, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] user: List of user object (required)
:param user: List of user object (required)
:type user: 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(user, **kwargs) # noqa: E501
@@ -291,23 +318,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(user, async_req=True)
>>> result = thread.get()
:param async_req bool: execute request asynchronously
:param list[User] user: List of user object (required)
:param user: List of user object (required)
:type user: 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()
@@ -380,21 +413,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
@@ -405,23 +443,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()
@@ -489,21 +533,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
@@ -513,23 +562,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()
@@ -601,22 +656,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
@@ -626,24 +687,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()
@@ -722,20 +790,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
@@ -745,22 +817,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()
@@ -822,22 +899,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, user, 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 user: Updated user object (required)
:param username: name that need to be deleted (required)
:type username: str
:param user: Updated user object (required)
:type user: 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, user, **kwargs) # noqa: E501
@@ -848,24 +931,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, user, 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 user: Updated user object (required)
:param username: name that need to be deleted (required)
:type username: str
:param user: Updated user object (required)
:type user: 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()

4
samples/openapi3/client/petstore/python/petstore_api/models/additional_properties_class.py
View File

@@ -73,7 +73,7 @@ class AdditionalPropertiesClass(object):
:param map_property: The map_property of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, str)
:type map_property: dict(str, str)
"""
self._map_property = map_property
@@ -94,7 +94,7 @@ class AdditionalPropertiesClass(object):
:param map_of_map_property: The map_of_map_property of this AdditionalPropertiesClass. # noqa: E501
:type: dict(str, dict(str, str))
:type map_of_map_property: dict(str, dict(str, str))
"""
self._map_of_map_property = map_of_map_property

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

@@ -77,7 +77,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
@@ -100,7 +100,7 @@ class Animal(object):
:param color: The color of this Animal. # noqa: E501
:type: str
:type color: str
"""
self._color = color

6
samples/openapi3/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/openapi3/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/openapi3/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/openapi3/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

12
samples/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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

16
samples/openapi3/client/petstore/python/petstore_api/models/enum_test.py
View File

@@ -101,7 +101,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
@@ -128,7 +128,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
@@ -157,7 +157,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
@@ -184,7 +184,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
@@ -211,7 +211,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
@@ -232,7 +232,7 @@ class EnumTest(object):
:param outer_enum_integer: The outer_enum_integer of this EnumTest. # noqa: E501
:type: OuterEnumInteger
:type outer_enum_integer: OuterEnumInteger
"""
self._outer_enum_integer = outer_enum_integer
@@ -253,7 +253,7 @@ class EnumTest(object):
:param outer_enum_default_value: The outer_enum_default_value of this EnumTest. # noqa: E501
:type: OuterEnumDefaultValue
:type outer_enum_default_value: OuterEnumDefaultValue
"""
self._outer_enum_default_value = outer_enum_default_value
@@ -274,7 +274,7 @@ class EnumTest(object):
:param outer_enum_integer_default_value: The outer_enum_integer_default_value of this EnumTest. # noqa: E501
:type: OuterEnumIntegerDefaultValue
:type outer_enum_integer_default_value: OuterEnumIntegerDefaultValue
"""
self._outer_enum_integer_default_value = outer_enum_integer_default_value

2
samples/openapi3/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/openapi3/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

2
samples/openapi3/client/petstore/python/petstore_api/models/foo.py
View File

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

30
samples/openapi3/client/petstore/python/petstore_api/models/format_test.py
View File

@@ -134,7 +134,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
@@ -161,7 +161,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
@@ -188,7 +188,7 @@ class FormatTest(object):
:param int64: The int64 of this FormatTest. # noqa: E501
:type: int
:type int64: int
"""
self._int64 = int64
@@ -209,7 +209,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
@@ -238,7 +238,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
@@ -265,7 +265,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
@@ -292,7 +292,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
@@ -316,7 +316,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
@@ -339,7 +339,7 @@ class FormatTest(object):
:param binary: The binary of this FormatTest. # noqa: E501
:type: file
:type binary: file
"""
self._binary = binary
@@ -360,7 +360,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
@@ -383,7 +383,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
@@ -404,7 +404,7 @@ class FormatTest(object):
:param uuid: The uuid of this FormatTest. # noqa: E501
:type: str
:type uuid: str
"""
self._uuid = uuid
@@ -425,7 +425,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
@@ -456,7 +456,7 @@ class FormatTest(object):
A string that is a 10 digit number. Can have leading zeros. # noqa: E501
:param pattern_with_digits: The pattern_with_digits of this FormatTest. # noqa: E501
:type: str
:type pattern_with_digits: str
"""
if (self.local_vars_configuration.client_side_validation and
pattern_with_digits is not None and not re.search(r'^\d{10}$', pattern_with_digits)): # noqa: E501
@@ -482,7 +482,7 @@ class FormatTest(object):
A string starting with 'image_' (case insensitive) and one to three digits following i.e. Image_01. # noqa: E501
:param pattern_with_digits_and_delimiter: The pattern_with_digits_and_delimiter of this FormatTest. # noqa: E501
:type: str
:type pattern_with_digits_and_delimiter: str
"""
if (self.local_vars_configuration.client_side_validation and
pattern_with_digits_and_delimiter is not None and not re.search(r'^image_\d{1,3}$', pattern_with_digits_and_delimiter, flags=re.IGNORECASE)): # noqa: E501

4
samples/openapi3/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/openapi3/client/petstore/python/petstore_api/models/health_check_result.py
View File

@@ -67,7 +67,7 @@ class HealthCheckResult(object):
:param nullable_message: The nullable_message of this HealthCheckResult. # noqa: E501
:type: str
:type nullable_message: str
"""
self._nullable_message = nullable_message

4
samples/openapi3/client/petstore/python/petstore_api/models/inline_object.py
View File

@@ -75,7 +75,7 @@ class InlineObject(object):
Updated name of the pet # noqa: E501
:param name: The name of this InlineObject. # noqa: E501
:type: str
:type name: str
"""
self._name = name
@@ -98,7 +98,7 @@ class InlineObject(object):
Updated status of the pet # noqa: E501
:param status: The status of this InlineObject. # noqa: E501
:type: str
:type status: str
"""
self._status = status

4
samples/openapi3/client/petstore/python/petstore_api/models/inline_object1.py
View File

@@ -75,7 +75,7 @@ class InlineObject1(object):
Additional data to pass to server # noqa: E501
:param additional_metadata: The additional_metadata of this InlineObject1. # noqa: E501
:type: str
:type additional_metadata: str
"""
self._additional_metadata = additional_metadata
@@ -98,7 +98,7 @@ class InlineObject1(object):
file to upload # noqa: E501
:param file: The file of this InlineObject1. # noqa: E501
:type: file
:type file: file
"""
self._file = file

4
samples/openapi3/client/petstore/python/petstore_api/models/inline_object2.py
View File

@@ -75,7 +75,7 @@ class InlineObject2(object):
Form parameter enum test (string array) # noqa: E501
:param enum_form_string_array: The enum_form_string_array of this InlineObject2. # noqa: E501
:type: list[str]
:type enum_form_string_array: list[str]
"""
allowed_values = [">", "$"] # noqa: E501
if (self.local_vars_configuration.client_side_validation and
@@ -106,7 +106,7 @@ class InlineObject2(object):
Form parameter enum test (string) # noqa: E501
:param enum_form_string: The enum_form_string of this InlineObject2. # noqa: E501
:type: str
:type enum_form_string: str
"""
allowed_values = ["_abc", "-efg", "(xyz)"] # noqa: E501
if self.local_vars_configuration.client_side_validation and enum_form_string not in allowed_values: # noqa: E501

28
samples/openapi3/client/petstore/python/petstore_api/models/inline_object3.py
View File

@@ -131,7 +131,7 @@ class InlineObject3(object):
None # noqa: E501
:param integer: The integer of this InlineObject3. # 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
@@ -160,7 +160,7 @@ class InlineObject3(object):
None # noqa: E501
:param int32: The int32 of this InlineObject3. # 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
@@ -189,7 +189,7 @@ class InlineObject3(object):
None # noqa: E501
:param int64: The int64 of this InlineObject3. # noqa: E501
:type: int
:type int64: int
"""
self._int64 = int64
@@ -212,7 +212,7 @@ class InlineObject3(object):
None # noqa: E501
:param number: The number of this InlineObject3. # 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
@@ -243,7 +243,7 @@ class InlineObject3(object):
None # noqa: E501
:param float: The float of this InlineObject3. # 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
@@ -269,7 +269,7 @@ class InlineObject3(object):
None # noqa: E501
:param double: The double of this InlineObject3. # noqa: E501
:type: float
:type double: float
"""
if self.local_vars_configuration.client_side_validation and double is None: # noqa: E501
raise ValueError("Invalid value for `double`, must not be `None`") # noqa: E501
@@ -300,7 +300,7 @@ class InlineObject3(object):
None # noqa: E501
:param string: The string of this InlineObject3. # 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
@@ -326,7 +326,7 @@ class InlineObject3(object):
None # noqa: E501
:param pattern_without_delimiter: The pattern_without_delimiter of this InlineObject3. # noqa: E501
:type: str
:type pattern_without_delimiter: str
"""
if self.local_vars_configuration.client_side_validation and pattern_without_delimiter is None: # noqa: E501
raise ValueError("Invalid value for `pattern_without_delimiter`, must not be `None`") # noqa: E501
@@ -354,7 +354,7 @@ class InlineObject3(object):
None # noqa: E501
:param byte: The byte of this InlineObject3. # 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
@@ -379,7 +379,7 @@ class InlineObject3(object):
None # noqa: E501
:param binary: The binary of this InlineObject3. # noqa: E501
:type: file
:type binary: file
"""
self._binary = binary
@@ -402,7 +402,7 @@ class InlineObject3(object):
None # noqa: E501
:param date: The date of this InlineObject3. # noqa: E501
:type: date
:type date: date
"""
self._date = date
@@ -425,7 +425,7 @@ class InlineObject3(object):
None # noqa: E501
:param date_time: The date_time of this InlineObject3. # noqa: E501
:type: datetime
:type date_time: datetime
"""
self._date_time = date_time
@@ -448,7 +448,7 @@ class InlineObject3(object):
None # noqa: E501
:param password: The password of this InlineObject3. # noqa: E501
:type: str
:type password: str
"""
if (self.local_vars_configuration.client_side_validation and
password is not None and len(password) > 64):
@@ -477,7 +477,7 @@ class InlineObject3(object):
None # noqa: E501
:param callback: The callback of this InlineObject3. # noqa: E501
:type: str
:type callback: str
"""
self._callback = callback

4
samples/openapi3/client/petstore/python/petstore_api/models/inline_object4.py
View File

@@ -73,7 +73,7 @@ class InlineObject4(object):
field1 # noqa: E501
:param param: The param of this InlineObject4. # noqa: E501
:type: str
:type param: str
"""
if self.local_vars_configuration.client_side_validation and param is None: # noqa: E501
raise ValueError("Invalid value for `param`, must not be `None`") # noqa: E501
@@ -98,7 +98,7 @@ class InlineObject4(object):
field2 # noqa: E501
:param param2: The param2 of this InlineObject4. # noqa: E501
:type: str
:type param2: str
"""
if self.local_vars_configuration.client_side_validation and param2 is None: # noqa: E501
raise ValueError("Invalid value for `param2`, must not be `None`") # noqa: E501

4
samples/openapi3/client/petstore/python/petstore_api/models/inline_object5.py
View File

@@ -74,7 +74,7 @@ class InlineObject5(object):
Additional data to pass to server # noqa: E501
:param additional_metadata: The additional_metadata of this InlineObject5. # noqa: E501
:type: str
:type additional_metadata: str
"""
self._additional_metadata = additional_metadata
@@ -97,7 +97,7 @@ class InlineObject5(object):
file to upload # noqa: E501
:param required_file: The required_file of this InlineObject5. # noqa: E501
:type: file
:type required_file: file
"""
if self.local_vars_configuration.client_side_validation and required_file is None: # noqa: E501
raise ValueError("Invalid value for `required_file`, must not be `None`") # noqa: E501

2
samples/openapi3/client/petstore/python/petstore_api/models/inline_response_default.py
View File

@@ -68,7 +68,7 @@ class InlineResponseDefault(object):
:param string: The string of this InlineResponseDefault. # noqa: E501
:type: Foo
:type string: Foo
"""
self._string = string

2
samples/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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

24
samples/openapi3/client/petstore/python/petstore_api/models/nullable_class.py
View File

@@ -113,7 +113,7 @@ class NullableClass(object):
:param integer_prop: The integer_prop of this NullableClass. # noqa: E501
:type: int
:type integer_prop: int
"""
self._integer_prop = integer_prop
@@ -134,7 +134,7 @@ class NullableClass(object):
:param number_prop: The number_prop of this NullableClass. # noqa: E501
:type: float
:type number_prop: float
"""
self._number_prop = number_prop
@@ -155,7 +155,7 @@ class NullableClass(object):
:param boolean_prop: The boolean_prop of this NullableClass. # noqa: E501
:type: bool
:type boolean_prop: bool
"""
self._boolean_prop = boolean_prop
@@ -176,7 +176,7 @@ class NullableClass(object):
:param string_prop: The string_prop of this NullableClass. # noqa: E501
:type: str
:type string_prop: str
"""
self._string_prop = string_prop
@@ -197,7 +197,7 @@ class NullableClass(object):
:param date_prop: The date_prop of this NullableClass. # noqa: E501
:type: date
:type date_prop: date
"""
self._date_prop = date_prop
@@ -218,7 +218,7 @@ class NullableClass(object):
:param datetime_prop: The datetime_prop of this NullableClass. # noqa: E501
:type: datetime
:type datetime_prop: datetime
"""
self._datetime_prop = datetime_prop
@@ -239,7 +239,7 @@ class NullableClass(object):
:param array_nullable_prop: The array_nullable_prop of this NullableClass. # noqa: E501
:type: list[object]
:type array_nullable_prop: list[object]
"""
self._array_nullable_prop = array_nullable_prop
@@ -260,7 +260,7 @@ class NullableClass(object):
:param array_and_items_nullable_prop: The array_and_items_nullable_prop of this NullableClass. # noqa: E501
:type: list[object]
:type array_and_items_nullable_prop: list[object]
"""
self._array_and_items_nullable_prop = array_and_items_nullable_prop
@@ -281,7 +281,7 @@ class NullableClass(object):
:param array_items_nullable: The array_items_nullable of this NullableClass. # noqa: E501
:type: list[object]
:type array_items_nullable: list[object]
"""
self._array_items_nullable = array_items_nullable
@@ -302,7 +302,7 @@ class NullableClass(object):
:param object_nullable_prop: The object_nullable_prop of this NullableClass. # noqa: E501
:type: dict(str, object)
:type object_nullable_prop: dict(str, object)
"""
self._object_nullable_prop = object_nullable_prop
@@ -323,7 +323,7 @@ class NullableClass(object):
:param object_and_items_nullable_prop: The object_and_items_nullable_prop of this NullableClass. # noqa: E501
:type: dict(str, object)
:type object_and_items_nullable_prop: dict(str, object)
"""
self._object_and_items_nullable_prop = object_and_items_nullable_prop
@@ -344,7 +344,7 @@ class NullableClass(object):
:param object_items_nullable: The object_items_nullable of this NullableClass. # noqa: E501
:type: dict(str, object)
:type object_items_nullable: dict(str, object)
"""
self._object_items_nullable = object_items_nullable

2
samples/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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/openapi3/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

16
samples/openapi3/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