From 6f6c8ede798836740dc166375dba411a0ffe35ae Mon Sep 17 00:00:00 2001 From: Alexey Volkov Date: Thu, 4 Jun 2020 08:46:35 -0700 Subject: [PATCH] [Python] Fixed docstrings in api.mustache (#6391) * [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 --- .../src/main/resources/python/api.mustache | 23 +- .../src/main/resources/python/model.mustache | 2 +- .../python/python-experimental/api.mustache | 1 + .../python-experimental/api_client.mustache | 15 +- .../petstore_api/api/another_fake_api.py | 23 +- .../petstore_api/api/fake_api.py | 508 ++++++++++++----- .../api/fake_classname_tags_123_api.py | 23 +- .../petstore_api/api/pet_api.py | 249 +++++--- .../petstore_api/api/store_api.py | 86 ++- .../petstore_api/api/user_api.py | 190 +++++-- .../models/additional_properties_any_type.py | 2 +- .../models/additional_properties_array.py | 2 +- .../models/additional_properties_boolean.py | 2 +- .../models/additional_properties_class.py | 22 +- .../models/additional_properties_integer.py | 2 +- .../models/additional_properties_number.py | 2 +- .../models/additional_properties_object.py | 2 +- .../models/additional_properties_string.py | 2 +- .../petstore_api/models/animal.py | 4 +- .../petstore_api/models/api_response.py | 6 +- .../models/array_of_array_of_number_only.py | 2 +- .../models/array_of_number_only.py | 2 +- .../petstore_api/models/array_test.py | 6 +- .../petstore_api/models/big_cat.py | 2 +- .../petstore_api/models/big_cat_all_of.py | 2 +- .../petstore_api/models/capitalization.py | 12 +- .../python-asyncio/petstore_api/models/cat.py | 2 +- .../petstore_api/models/cat_all_of.py | 2 +- .../petstore_api/models/category.py | 4 +- .../petstore_api/models/class_model.py | 2 +- .../petstore_api/models/client.py | 2 +- .../python-asyncio/petstore_api/models/dog.py | 2 +- .../petstore_api/models/dog_all_of.py | 2 +- .../petstore_api/models/enum_arrays.py | 4 +- .../petstore_api/models/enum_test.py | 10 +- .../petstore_api/models/file.py | 2 +- .../models/file_schema_test_class.py | 4 +- .../petstore_api/models/format_test.py | 28 +- .../petstore_api/models/has_only_read_only.py | 4 +- .../petstore_api/models/list.py | 2 +- .../petstore_api/models/map_test.py | 8 +- ...perties_and_additional_properties_class.py | 6 +- .../petstore_api/models/model200_response.py | 4 +- .../petstore_api/models/model_return.py | 2 +- .../petstore_api/models/name.py | 8 +- .../petstore_api/models/number_only.py | 2 +- .../petstore_api/models/order.py | 12 +- .../petstore_api/models/outer_composite.py | 6 +- .../python-asyncio/petstore_api/models/pet.py | 12 +- .../petstore_api/models/read_only_first.py | 4 +- .../petstore_api/models/special_model_name.py | 2 +- .../python-asyncio/petstore_api/models/tag.py | 4 +- .../models/type_holder_default.py | 10 +- .../models/type_holder_example.py | 12 +- .../petstore_api/models/user.py | 16 +- .../petstore_api/models/xml_item.py | 58 +- .../petstore_api/api/another_fake_api.py | 1 + .../petstore_api/api/fake_api.py | 15 + .../api/fake_classname_tags_123_api.py | 1 + .../petstore_api/api/pet_api.py | 9 + .../petstore_api/api/store_api.py | 4 + .../petstore_api/api/user_api.py | 8 + .../petstore_api/api_client.py | 15 +- .../petstore_api/api/another_fake_api.py | 23 +- .../petstore_api/api/fake_api.py | 508 ++++++++++++----- .../api/fake_classname_tags_123_api.py | 23 +- .../petstore_api/api/pet_api.py | 249 +++++--- .../petstore_api/api/store_api.py | 86 ++- .../petstore_api/api/user_api.py | 190 +++++-- .../models/additional_properties_any_type.py | 2 +- .../models/additional_properties_array.py | 2 +- .../models/additional_properties_boolean.py | 2 +- .../models/additional_properties_class.py | 22 +- .../models/additional_properties_integer.py | 2 +- .../models/additional_properties_number.py | 2 +- .../models/additional_properties_object.py | 2 +- .../models/additional_properties_string.py | 2 +- .../petstore_api/models/animal.py | 4 +- .../petstore_api/models/api_response.py | 6 +- .../models/array_of_array_of_number_only.py | 2 +- .../models/array_of_number_only.py | 2 +- .../petstore_api/models/array_test.py | 6 +- .../petstore_api/models/big_cat.py | 2 +- .../petstore_api/models/big_cat_all_of.py | 2 +- .../petstore_api/models/capitalization.py | 12 +- .../python-tornado/petstore_api/models/cat.py | 2 +- .../petstore_api/models/cat_all_of.py | 2 +- .../petstore_api/models/category.py | 4 +- .../petstore_api/models/class_model.py | 2 +- .../petstore_api/models/client.py | 2 +- .../python-tornado/petstore_api/models/dog.py | 2 +- .../petstore_api/models/dog_all_of.py | 2 +- .../petstore_api/models/enum_arrays.py | 4 +- .../petstore_api/models/enum_test.py | 10 +- .../petstore_api/models/file.py | 2 +- .../models/file_schema_test_class.py | 4 +- .../petstore_api/models/format_test.py | 28 +- .../petstore_api/models/has_only_read_only.py | 4 +- .../petstore_api/models/list.py | 2 +- .../petstore_api/models/map_test.py | 8 +- ...perties_and_additional_properties_class.py | 6 +- .../petstore_api/models/model200_response.py | 4 +- .../petstore_api/models/model_return.py | 2 +- .../petstore_api/models/name.py | 8 +- .../petstore_api/models/number_only.py | 2 +- .../petstore_api/models/order.py | 12 +- .../petstore_api/models/outer_composite.py | 6 +- .../python-tornado/petstore_api/models/pet.py | 12 +- .../petstore_api/models/read_only_first.py | 4 +- .../petstore_api/models/special_model_name.py | 2 +- .../python-tornado/petstore_api/models/tag.py | 4 +- .../models/type_holder_default.py | 10 +- .../models/type_holder_example.py | 12 +- .../petstore_api/models/user.py | 16 +- .../petstore_api/models/xml_item.py | 58 +- .../petstore_api/api/another_fake_api.py | 23 +- .../python/petstore_api/api/fake_api.py | 508 ++++++++++++----- .../api/fake_classname_tags_123_api.py | 23 +- .../python/petstore_api/api/pet_api.py | 249 +++++--- .../python/petstore_api/api/store_api.py | 86 ++- .../python/petstore_api/api/user_api.py | 190 +++++-- .../models/additional_properties_any_type.py | 2 +- .../models/additional_properties_array.py | 2 +- .../models/additional_properties_boolean.py | 2 +- .../models/additional_properties_class.py | 22 +- .../models/additional_properties_integer.py | 2 +- .../models/additional_properties_number.py | 2 +- .../models/additional_properties_object.py | 2 +- .../models/additional_properties_string.py | 2 +- .../python/petstore_api/models/animal.py | 4 +- .../petstore_api/models/api_response.py | 6 +- .../models/array_of_array_of_number_only.py | 2 +- .../models/array_of_number_only.py | 2 +- .../python/petstore_api/models/array_test.py | 6 +- .../python/petstore_api/models/big_cat.py | 2 +- .../petstore_api/models/big_cat_all_of.py | 2 +- .../petstore_api/models/capitalization.py | 12 +- .../python/petstore_api/models/cat.py | 2 +- .../python/petstore_api/models/cat_all_of.py | 2 +- .../python/petstore_api/models/category.py | 4 +- .../python/petstore_api/models/class_model.py | 2 +- .../python/petstore_api/models/client.py | 2 +- .../python/petstore_api/models/dog.py | 2 +- .../python/petstore_api/models/dog_all_of.py | 2 +- .../python/petstore_api/models/enum_arrays.py | 4 +- .../python/petstore_api/models/enum_test.py | 10 +- .../python/petstore_api/models/file.py | 2 +- .../models/file_schema_test_class.py | 4 +- .../python/petstore_api/models/format_test.py | 28 +- .../petstore_api/models/has_only_read_only.py | 4 +- .../python/petstore_api/models/list.py | 2 +- .../python/petstore_api/models/map_test.py | 8 +- ...perties_and_additional_properties_class.py | 6 +- .../petstore_api/models/model200_response.py | 4 +- .../petstore_api/models/model_return.py | 2 +- .../python/petstore_api/models/name.py | 8 +- .../python/petstore_api/models/number_only.py | 2 +- .../python/petstore_api/models/order.py | 12 +- .../petstore_api/models/outer_composite.py | 6 +- .../python/petstore_api/models/pet.py | 12 +- .../petstore_api/models/read_only_first.py | 4 +- .../petstore_api/models/special_model_name.py | 2 +- .../python/petstore_api/models/tag.py | 4 +- .../models/type_holder_default.py | 10 +- .../models/type_holder_example.py | 12 +- .../python/petstore_api/models/user.py | 16 +- .../python/petstore_api/models/xml_item.py | 58 +- .../petstore_api/api/another_fake_api.py | 1 + .../petstore_api/api/default_api.py | 1 + .../petstore_api/api/fake_api.py | 14 + .../api/fake_classname_tags_123_api.py | 1 + .../petstore_api/api/pet_api.py | 9 + .../petstore_api/api/store_api.py | 4 + .../petstore_api/api/user_api.py | 8 + .../petstore_api/api_client.py | 15 +- .../petstore_api/api/another_fake_api.py | 23 +- .../python/petstore_api/api/default_api.py | 17 +- .../python/petstore_api/api/fake_api.py | 537 +++++++++++++----- .../api/fake_classname_tags_123_api.py | 23 +- .../python/petstore_api/api/pet_api.py | 249 +++++--- .../python/petstore_api/api/store_api.py | 86 ++- .../python/petstore_api/api/user_api.py | 190 +++++-- .../models/additional_properties_class.py | 4 +- .../python/petstore_api/models/animal.py | 4 +- .../petstore_api/models/api_response.py | 6 +- .../models/array_of_array_of_number_only.py | 2 +- .../models/array_of_number_only.py | 2 +- .../python/petstore_api/models/array_test.py | 6 +- .../petstore_api/models/capitalization.py | 12 +- .../python/petstore_api/models/cat.py | 2 +- .../python/petstore_api/models/cat_all_of.py | 2 +- .../python/petstore_api/models/category.py | 4 +- .../python/petstore_api/models/class_model.py | 2 +- .../python/petstore_api/models/client.py | 2 +- .../python/petstore_api/models/dog.py | 2 +- .../python/petstore_api/models/dog_all_of.py | 2 +- .../python/petstore_api/models/enum_arrays.py | 4 +- .../python/petstore_api/models/enum_test.py | 16 +- .../python/petstore_api/models/file.py | 2 +- .../models/file_schema_test_class.py | 4 +- .../python/petstore_api/models/foo.py | 2 +- .../python/petstore_api/models/format_test.py | 30 +- .../petstore_api/models/has_only_read_only.py | 4 +- .../models/health_check_result.py | 2 +- .../petstore_api/models/inline_object.py | 4 +- .../petstore_api/models/inline_object1.py | 4 +- .../petstore_api/models/inline_object2.py | 4 +- .../petstore_api/models/inline_object3.py | 28 +- .../petstore_api/models/inline_object4.py | 4 +- .../petstore_api/models/inline_object5.py | 4 +- .../models/inline_response_default.py | 2 +- .../python/petstore_api/models/list.py | 2 +- .../python/petstore_api/models/map_test.py | 8 +- ...perties_and_additional_properties_class.py | 6 +- .../petstore_api/models/model200_response.py | 4 +- .../petstore_api/models/model_return.py | 2 +- .../python/petstore_api/models/name.py | 8 +- .../petstore_api/models/nullable_class.py | 24 +- .../python/petstore_api/models/number_only.py | 2 +- .../python/petstore_api/models/order.py | 12 +- .../petstore_api/models/outer_composite.py | 6 +- .../python/petstore_api/models/pet.py | 12 +- .../petstore_api/models/read_only_first.py | 4 +- .../petstore_api/models/special_model_name.py | 2 +- .../python/petstore_api/models/tag.py | 4 +- .../python/petstore_api/models/user.py | 16 +- .../.openapi-generator/VERSION | 2 +- .../controllers/pet_controller.py | 4 +- .../openapi_server/openapi/openapi.yaml | 18 - .../test/test_pet_controller.py | 2 - .../python-flask-python2/requirements.txt | 16 +- .../test-requirements.txt | 2 +- .../petstore/python-flask-python2/tox.ini | 4 +- .../python-flask/.openapi-generator/VERSION | 2 +- .../controllers/pet_controller.py | 4 +- .../openapi_server/openapi/openapi.yaml | 18 - .../test/test_pet_controller.py | 2 - .../petstore/python-flask/requirements.txt | 11 +- .../python-flask/test-requirements.txt | 2 +- .../server/petstore/python-flask/tox.ini | 4 +- 240 files changed, 3920 insertions(+), 1882 deletions(-) diff --git a/modules/openapi-generator/src/main/resources/python/api.mustache b/modules/openapi-generator/src/main/resources/python/api.mustache index f2c554183547..18ced57845ee 100644 --- a/modules/openapi-generator/src/main/resources/python/api.mustache +++ b/modules/openapi-generator/src/main/resources/python/api.mustache @@ -38,6 +38,7 @@ class {{classname}}(object): {{/notes}} This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + {{#sortParamsByRequiredFlag}} >>> thread = api.{{operationId}}({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}async_req=True) {{/sortParamsByRequiredFlag}} @@ -46,20 +47,24 @@ class {{classname}}(object): {{/sortParamsByRequiredFlag}} >>> result = thread.get() - :param async_req bool: execute request asynchronously {{#allParams}} - :param {{dataType}} {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}} + :param {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}} + :type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}} {{/allParams}} + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: {{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}None{{/returnType}} + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: {{#returnType}}{{returnType}}{{/returnType}}{{^returnType}}None{{/returnType}} """ kwargs['_return_http_data_only'] = True return self.{{operationId}}_with_http_info({{#sortParamsByRequiredFlag}}{{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}{{/sortParamsByRequiredFlag}}**kwargs) # noqa: E501 @@ -72,6 +77,7 @@ class {{classname}}(object): {{/notes}} This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + {{#sortParamsByRequiredFlag}} >>> thread = api.{{operationId}}_with_http_info({{#allParams}}{{#required}}{{paramName}}, {{/required}}{{/allParams}}async_req=True) {{/sortParamsByRequiredFlag}} @@ -80,22 +86,27 @@ class {{classname}}(object): {{/sortParamsByRequiredFlag}} >>> result = thread.get() - :param async_req bool: execute request asynchronously {{#allParams}} - :param {{dataType}} {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional{{#defaultValue}}, default to {{{.}}}{{/defaultValue}}){{/optional}} + :param {{paramName}}:{{#description}} {{{description}}}{{/description}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}} + :type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}} {{/allParams}} + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: {{#returnType}}tuple({{returnType}}, status_code(int), headers(HTTPHeaderDict)){{/returnType}}{{^returnType}}None{{/returnType}} + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: {{#returnType}}tuple({{returnType}}, status_code(int), headers(HTTPHeaderDict)){{/returnType}}{{^returnType}}None{{/returnType}} """ {{#servers.0}} diff --git a/modules/openapi-generator/src/main/resources/python/model.mustache b/modules/openapi-generator/src/main/resources/python/model.mustache index 112246604dc5..2b3299a6f2b9 100644 --- a/modules/openapi-generator/src/main/resources/python/model.mustache +++ b/modules/openapi-generator/src/main/resources/python/model.mustache @@ -107,7 +107,7 @@ class {{classname}}(object): {{/description}} :param {{name}}: The {{name}} of this {{classname}}. # noqa: E501 - :type: {{dataType}} + :type {{name}}: {{dataType}} """ {{^isNullable}} {{#required}} diff --git a/modules/openapi-generator/src/main/resources/python/python-experimental/api.mustache b/modules/openapi-generator/src/main/resources/python/python-experimental/api.mustache index 44fc3a89970f..92e909165d6e 100644 --- a/modules/openapi-generator/src/main/resources/python/python-experimental/api.mustache +++ b/modules/openapi-generator/src/main/resources/python/python-experimental/api.mustache @@ -66,6 +66,7 @@ class {{classname}}(object): {{/notes}} This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.{{operationId}}({{#requiredParams}}{{^defaultValue}}{{paramName}}, {{/defaultValue}}{{/requiredParams}}{{#requiredParams}}{{#defaultValue}}{{paramName}}={{{defaultValue}}}, {{/defaultValue}}{{/requiredParams}}async_req=True) >>> result = thread.get() diff --git a/modules/openapi-generator/src/main/resources/python/python-experimental/api_client.mustache b/modules/openapi-generator/src/main/resources/python/python-experimental/api_client.mustache index 5285a7b80644..d17177a8328b 100644 --- a/modules/openapi-generator/src/main/resources/python/python-experimental/api_client.mustache +++ b/modules/openapi-generator/src/main/resources/python/python-experimental/api_client.mustache @@ -291,6 +291,7 @@ class ApiClient(object): ({str: (bool, str, int, float, date, datetime, str, none_type)},) :param _check_type: boolean, whether to check the types of the data received from the server + :type _check_type: bool :return: deserialized object. """ @@ -350,22 +351,28 @@ class ApiClient(object): (float, none_type) ([int, none_type],) ({str: (bool, str, int, float, date, datetime, str, none_type)},) - :param files dict: key -> field name, value -> a list of open file + :param files: key -> field name, value -> a list of open file objects for `multipart/form-data`. + :type files: dict :param async_req bool: execute request asynchronously + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param collection_formats: dict of collection formats for path, query, header, and post parameters. + :type collection_formats: dict, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _check_type: boolean describing if the data back from the server should have its type checked. + :type _check_type: bool, optional :return: If async_req parameter is True, the request will be called asynchronously. @@ -559,9 +566,9 @@ class ApiClient(object): :param headers: Header parameters dict to be updated. :param querys: Query parameters tuple list to be updated. :param auth_settings: Authentication setting identifiers list. - :resource_path: A string representation of the HTTP request resource path. - :method: A string representation of the HTTP request method. - :body: A object representing the body of the HTTP request. + :param resource_path: A string representation of the HTTP request resource path. + :param method: A string representation of the HTTP request method. + :param body: A object representing the body of the HTTP request. The object type is the return value of sanitize_for_serialization(). """ if not auth_settings: diff --git a/samples/client/petstore/python-asyncio/petstore_api/api/another_fake_api.py b/samples/client/petstore/python-asyncio/petstore_api/api/another_fake_api.py index 77c4c003fe4e..4d69b287ca8b 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/api/another_fake_api.py +++ b/samples/client/petstore/python-asyncio/petstore_api/api/another_fake_api.py @@ -42,21 +42,26 @@ def call_123_test_special_tags(self, body, **kwargs): # noqa: E501 To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.call_123_test_special_tags_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def call_123_test_special_tags_with_http_info(self, body, **kwargs): # noqa: E5 To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python-asyncio/petstore_api/api/fake_api.py b/samples/client/petstore/python-asyncio/petstore_api/api/fake_api.py index 667c50612ce6..e1d9ffebebfe 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/api/fake_api.py +++ b/samples/client/petstore/python-asyncio/petstore_api/api/fake_api.py @@ -42,21 +42,26 @@ def create_xml_item(self, xml_item, **kwargs): # noqa: E501 this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item(xml_item, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param XmlItem xml_item: XmlItem Body (required) + :param xml_item: XmlItem Body (required) + :type xml_item: XmlItem + :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_xml_item_with_http_info(xml_item, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def create_xml_item_with_http_info(self, xml_item, **kwargs): # noqa: E501 this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item_with_http_info(xml_item, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param XmlItem xml_item: XmlItem Body (required) + :param xml_item: XmlItem Body (required) + :type xml_item: XmlItem + :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() @@ -156,21 +167,26 @@ def fake_outer_boolean_serialize(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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: bool + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: bool """ kwargs['_return_http_data_only'] = True return self.fake_outer_boolean_serialize_with_http_info(**kwargs) # noqa: E501 @@ -181,23 +197,29 @@ def fake_outer_boolean_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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(bool, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(bool, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -266,21 +288,26 @@ def fake_outer_composite_serialize(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite body: Input composite as post body + :param body: Input composite as post body + :type body: OuterComposite + :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: OuterComposite + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: OuterComposite """ kwargs['_return_http_data_only'] = True return self.fake_outer_composite_serialize_with_http_info(**kwargs) # noqa: E501 @@ -291,23 +318,29 @@ def fake_outer_composite_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite body: Input composite as post body + :param body: Input composite as post body + :type body: OuterComposite + :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(OuterComposite, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(OuterComposite, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -376,21 +409,26 @@ def fake_outer_number_serialize(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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: float + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: float """ kwargs['_return_http_data_only'] = True return self.fake_outer_number_serialize_with_http_info(**kwargs) # noqa: E501 @@ -401,23 +439,29 @@ def fake_outer_number_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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(float, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(float, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -486,21 +530,26 @@ def fake_outer_string_serialize(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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.fake_outer_string_serialize_with_http_info(**kwargs) # noqa: E501 @@ -511,23 +560,29 @@ def fake_outer_string_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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() @@ -596,21 +651,26 @@ def test_body_with_file_schema(self, body, **kwargs): # noqa: E501 For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass body: (required) + :param body: (required) + :type body: FileSchemaTestClass + :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.test_body_with_file_schema_with_http_info(body, **kwargs) # noqa: E501 @@ -621,23 +681,29 @@ def test_body_with_file_schema_with_http_info(self, body, **kwargs): # noqa: E5 For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass body: (required) + :param body: (required) + :type body: FileSchemaTestClass + :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() @@ -709,22 +775,28 @@ def test_body_with_query_params(self, query, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params(query, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User body: (required) + :param query: (required) + :type query: str + :param body: (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.test_body_with_query_params_with_http_info(query, body, **kwargs) # noqa: E501 @@ -734,24 +806,31 @@ def test_body_with_query_params_with_http_info(self, query, body, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params_with_http_info(query, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User body: (required) + :param query: (required) + :type query: str + :param body: (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -831,21 +910,26 @@ def test_client_model(self, body, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.test_client_model_with_http_info(body, **kwargs) # noqa: E501 @@ -856,23 +940,29 @@ def test_client_model_with_http_info(self, body, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -949,34 +1039,52 @@ def test_endpoint_parameters(self, number, double, pattern_without_delimiter, by Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, **kwargs) # noqa: E501 @@ -987,36 +1095,55 @@ def test_endpoint_parameters_with_http_info(self, number, double, pattern_withou Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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() @@ -1168,28 +1295,40 @@ def test_enum_parameters(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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.test_enum_parameters_with_http_info(**kwargs) # noqa: E501 @@ -1200,30 +1339,43 @@ def test_enum_parameters_with_http_info(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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() @@ -1316,26 +1468,36 @@ def test_group_parameters(self, required_string_group, required_boolean_group, r Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: 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.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, **kwargs) # noqa: E501 @@ -1346,28 +1508,39 @@ def test_group_parameters_with_http_info(self, required_string_group, required_b Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -1458,21 +1631,26 @@ def test_inline_additional_properties(self, param, **kwargs): # 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_inline_additional_properties(param, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) param: request body (required) + :param param: request body (required) + :type param: dict(str, 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.test_inline_additional_properties_with_http_info(param, **kwargs) # noqa: E501 @@ -1482,23 +1660,29 @@ def test_inline_additional_properties_with_http_info(self, param, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties_with_http_info(param, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) param: request body (required) + :param param: request body (required) + :type param: dict(str, 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() @@ -1570,22 +1754,28 @@ def test_json_form_data(self, param, param2, **kwargs): # 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_json_form_data(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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.test_json_form_data_with_http_info(param, param2, **kwargs) # noqa: E501 @@ -1595,24 +1785,31 @@ def test_json_form_data_with_http_info(self, param, param2, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_json_form_data_with_http_info(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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() @@ -1692,25 +1889,34 @@ def test_query_parameter_collection_format(self, pipe, ioutil, http, url, contex To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: 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.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, **kwargs) # noqa: E501 @@ -1721,27 +1927,37 @@ def test_query_parameter_collection_format_with_http_info(self, pipe, ioutil, ht To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/client/petstore/python-asyncio/petstore_api/api/fake_classname_tags_123_api.py b/samples/client/petstore/python-asyncio/petstore_api/api/fake_classname_tags_123_api.py index 2bb189bd01b9..d963591a49a8 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/api/fake_classname_tags_123_api.py +++ b/samples/client/petstore/python-asyncio/petstore_api/api/fake_classname_tags_123_api.py @@ -42,21 +42,26 @@ def test_classname(self, body, **kwargs): # noqa: E501 To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.test_classname_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def test_classname_with_http_info(self, body, **kwargs): # noqa: E501 To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python-asyncio/petstore_api/api/pet_api.py b/samples/client/petstore/python-asyncio/petstore_api/api/pet_api.py index 5a297a57647b..7002fe32740f 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/api/pet_api.py +++ b/samples/client/petstore/python-asyncio/petstore_api/api/pet_api.py @@ -41,21 +41,26 @@ def add_pet(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.add_pet_with_http_info(body, **kwargs) # noqa: E501 @@ -65,23 +70,29 @@ def add_pet_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -153,22 +164,28 @@ def delete_pet(self, pet_id, **kwargs): # 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_pet(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: Pet id to delete (required) - :param str api_key: + :param pet_id: Pet id to delete (required) + :type pet_id: int + :param api_key: + :type api_key: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.delete_pet_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -178,24 +195,31 @@ def delete_pet_with_http_info(self, pet_id, **kwargs): # 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_pet_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: Pet id to delete (required) - :param str api_key: + :param pet_id: Pet id to delete (required) + :type pet_id: int + :param api_key: + :type api_key: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -267,21 +291,26 @@ def find_pets_by_status(self, status, **kwargs): # noqa: E501 Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status(status, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] status: Status values that need to be considered for filter (required) + :param status: Status values that need to be considered for filter (required) + :type status: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: list[Pet] + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: list[Pet] """ kwargs['_return_http_data_only'] = True return self.find_pets_by_status_with_http_info(status, **kwargs) # noqa: E501 @@ -292,23 +321,29 @@ def find_pets_by_status_with_http_info(self, status, **kwargs): # noqa: E501 Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status_with_http_info(status, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] status: Status values that need to be considered for filter (required) + :param status: Status values that need to be considered for filter (required) + :type status: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -382,21 +417,26 @@ def find_pets_by_tags(self, tags, **kwargs): # noqa: E501 Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags(tags, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] tags: Tags to filter by (required) + :param tags: Tags to filter by (required) + :type tags: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: list[Pet] + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: list[Pet] """ kwargs['_return_http_data_only'] = True return self.find_pets_by_tags_with_http_info(tags, **kwargs) # noqa: E501 @@ -407,23 +447,29 @@ def find_pets_by_tags_with_http_info(self, tags, **kwargs): # noqa: E501 Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags_with_http_info(tags, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] tags: Tags to filter by (required) + :param tags: Tags to filter by (required) + :type tags: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -497,21 +543,26 @@ def get_pet_by_id(self, pet_id, **kwargs): # noqa: E501 Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to return (required) + :param pet_id: ID of pet to return (required) + :type pet_id: int + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Pet + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Pet """ kwargs['_return_http_data_only'] = True return self.get_pet_by_id_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -522,23 +573,29 @@ def get_pet_by_id_with_http_info(self, pet_id, **kwargs): # noqa: E501 Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to return (required) + :param pet_id: ID of pet to return (required) + :type pet_id: int + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Pet, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Pet, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -610,21 +667,26 @@ def update_pet(self, body, **kwargs): # 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_pet(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_pet_with_http_info(body, **kwargs) # noqa: E501 @@ -634,23 +696,29 @@ def update_pet_with_http_info(self, body, **kwargs): # 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_pet_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -722,23 +790,30 @@ def update_pet_with_form(self, pet_id, **kwargs): # 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_pet_with_form(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet that needs to be updated (required) - :param str name: Updated name of the pet - :param str status: Updated status of the pet + :param pet_id: ID of pet that needs to be updated (required) + :type pet_id: int + :param name: Updated name of the pet + :type name: str + :param status: Updated status of the pet + :type status: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_pet_with_form_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -748,25 +823,33 @@ def update_pet_with_form_with_http_info(self, pet_id, **kwargs): # 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_pet_with_form_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet that needs to be updated (required) - :param str name: Updated name of the pet - :param str status: Updated status of the pet + :param pet_id: ID of pet that needs to be updated (required) + :type pet_id: int + :param name: Updated name of the pet + :type name: str + :param status: Updated status of the pet + :type status: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -844,23 +927,30 @@ def upload_file(self, pet_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param str additional_metadata: Additional data to pass to server - :param file file: file to upload + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param file: file to upload + :type file: file + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiResponse """ kwargs['_return_http_data_only'] = True return self.upload_file_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -870,25 +960,33 @@ def upload_file_with_http_info(self, pet_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param str additional_metadata: Additional data to pass to server - :param file file: file to upload + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param file: file to upload + :type file: file + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -970,23 +1068,30 @@ def upload_file_with_required_file(self, pet_id, required_file, **kwargs): # no This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file_with_required_file(pet_id, required_file, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param file required_file: file to upload (required) - :param str additional_metadata: Additional data to pass to server + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param required_file: file to upload (required) + :type required_file: file + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiResponse """ kwargs['_return_http_data_only'] = True return self.upload_file_with_required_file_with_http_info(pet_id, required_file, **kwargs) # noqa: E501 @@ -996,25 +1101,33 @@ def upload_file_with_required_file_with_http_info(self, pet_id, required_file, * 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() diff --git a/samples/client/petstore/python-asyncio/petstore_api/api/store_api.py b/samples/client/petstore/python-asyncio/petstore_api/api/store_api.py index f693f755b745..0ede23f05ba2 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/api/store_api.py +++ b/samples/client/petstore/python-asyncio/petstore_api/api/store_api.py @@ -42,21 +42,26 @@ def delete_order(self, order_id, **kwargs): # noqa: E501 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 @@ def delete_order_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def get_inventory(self, **kwargs): # noqa: E501 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 @@ def get_inventory_with_http_info(self, **kwargs): # noqa: E501 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 @@ def get_order_by_id(self, order_id, **kwargs): # noqa: E501 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 @@ def get_order_by_id_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def place_order(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Order body: order placed for purchasing the pet (required) + :param body: order placed for purchasing the pet (required) + :type body: Order + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Order + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Order """ kwargs['_return_http_data_only'] = True return self.place_order_with_http_info(body, **kwargs) # noqa: E501 @@ -398,23 +434,29 @@ def place_order_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Order body: order placed for purchasing the pet (required) + :param body: order placed for purchasing the pet (required) + :type body: Order + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Order, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python-asyncio/petstore_api/api/user_api.py b/samples/client/petstore/python-asyncio/petstore_api/api/user_api.py index 9462f00716a3..a912483b023b 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/api/user_api.py +++ b/samples/client/petstore/python-asyncio/petstore_api/api/user_api.py @@ -42,21 +42,26 @@ def create_user(self, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param User body: Created user object (required) + :param body: Created user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_user_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def create_user_with_http_info(self, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param User body: Created user object (required) + :param body: Created user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -151,21 +162,26 @@ def create_users_with_array_input(self, body, **kwargs): # 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_users_with_array_input(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_users_with_array_input_with_http_info(body, **kwargs) # noqa: E501 @@ -175,23 +191,29 @@ def create_users_with_array_input_with_http_info(self, body, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_array_input_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -259,21 +281,26 @@ def create_users_with_list_input(self, body, **kwargs): # 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_users_with_list_input(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_users_with_list_input_with_http_info(body, **kwargs) # noqa: E501 @@ -283,23 +310,29 @@ def create_users_with_list_input_with_http_info(self, body, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_list_input_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -368,21 +401,26 @@ def delete_user(self, username, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be deleted (required) + :param username: The name that needs to be deleted (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.delete_user_with_http_info(username, **kwargs) # noqa: E501 @@ -393,23 +431,29 @@ def delete_user_with_http_info(self, username, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user_with_http_info(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be deleted (required) + :param username: The name that needs to be deleted (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -477,21 +521,26 @@ def get_user_by_name(self, username, **kwargs): # 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_user_by_name(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be fetched. Use user1 for testing. (required) + :param username: The name that needs to be fetched. Use user1 for testing. (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: User + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: User """ kwargs['_return_http_data_only'] = True return self.get_user_by_name_with_http_info(username, **kwargs) # noqa: E501 @@ -501,23 +550,29 @@ def get_user_by_name_with_http_info(self, username, **kwargs): # 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_user_by_name_with_http_info(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be fetched. Use user1 for testing. (required) + :param username: The name that needs to be fetched. Use user1 for testing. (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(User, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(User, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -589,22 +644,28 @@ def login_user(self, username, password, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user(username, password, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The user name for login (required) - :param str password: The password for login in clear text (required) + :param username: The user name for login (required) + :type username: str + :param password: The password for login in clear text (required) + :type password: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: str + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: str """ kwargs['_return_http_data_only'] = True return self.login_user_with_http_info(username, password, **kwargs) # noqa: E501 @@ -614,24 +675,31 @@ def login_user_with_http_info(self, username, password, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user_with_http_info(username, password, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The user name for login (required) - :param str password: The password for login in clear text (required) + :param username: The user name for login (required) + :type username: str + :param password: The password for login in clear text (required) + :type password: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(str, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(str, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -710,20 +778,24 @@ def logout_user(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.logout_user_with_http_info(**kwargs) # noqa: E501 @@ -733,22 +805,27 @@ def logout_user_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -810,22 +887,28 @@ def update_user(self, username, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user(username, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: name that need to be deleted (required) - :param User body: Updated user object (required) + :param username: name that need to be deleted (required) + :type username: str + :param body: Updated user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_user_with_http_info(username, body, **kwargs) # noqa: E501 @@ -836,24 +919,31 @@ def update_user_with_http_info(self, username, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user_with_http_info(username, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: name that need to be deleted (required) - :param User body: Updated user object (required) + :param username: name that need to be deleted (required) + :type username: str + :param body: Updated user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_any_type.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_any_type.py index 2954285de87c..690c71705b9c 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_any_type.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_any_type.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesAnyType. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_array.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_array.py index c6369c22a12f..f0902bdaffac 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_array.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_array.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesArray. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_boolean.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_boolean.py index 599b7c8b8843..f79d2609a1df 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_boolean.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_boolean.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesBoolean. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_class.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_class.py index be4455c683bf..ca334635175d 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_class.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_class.py @@ -118,7 +118,7 @@ def map_string(self, map_string): :param map_string: The map_string of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, str) + :type map_string: dict(str, str) """ self._map_string = map_string @@ -139,7 +139,7 @@ def map_number(self, map_number): :param map_number: The map_number of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, float) + :type map_number: dict(str, float) """ self._map_number = map_number @@ -160,7 +160,7 @@ def map_integer(self, map_integer): :param map_integer: The map_integer of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, int) + :type map_integer: dict(str, int) """ self._map_integer = map_integer @@ -181,7 +181,7 @@ def map_boolean(self, map_boolean): :param map_boolean: The map_boolean of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, bool) + :type map_boolean: dict(str, bool) """ self._map_boolean = map_boolean @@ -202,7 +202,7 @@ def map_array_integer(self, map_array_integer): :param map_array_integer: The map_array_integer of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, list[int]) + :type map_array_integer: dict(str, list[int]) """ self._map_array_integer = map_array_integer @@ -223,7 +223,7 @@ def map_array_anytype(self, map_array_anytype): :param map_array_anytype: The map_array_anytype of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, list[object]) + :type map_array_anytype: dict(str, list[object]) """ self._map_array_anytype = map_array_anytype @@ -244,7 +244,7 @@ def map_map_string(self, map_map_string): :param map_map_string: The map_map_string of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, dict(str, str)) + :type map_map_string: dict(str, dict(str, str)) """ self._map_map_string = map_map_string @@ -265,7 +265,7 @@ def map_map_anytype(self, map_map_anytype): :param map_map_anytype: The map_map_anytype of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, dict(str, object)) + :type map_map_anytype: dict(str, dict(str, object)) """ self._map_map_anytype = map_map_anytype @@ -286,7 +286,7 @@ def anytype_1(self, anytype_1): :param anytype_1: The anytype_1 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_1: object """ self._anytype_1 = anytype_1 @@ -307,7 +307,7 @@ def anytype_2(self, anytype_2): :param anytype_2: The anytype_2 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_2: object """ self._anytype_2 = anytype_2 @@ -328,7 +328,7 @@ def anytype_3(self, anytype_3): :param anytype_3: The anytype_3 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_3: object """ self._anytype_3 = anytype_3 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_integer.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_integer.py index ddbb85fdf33b..5c3ebf230d10 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_integer.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_integer.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesInteger. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_number.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_number.py index 8bbeda83ecca..0e7f34ed329f 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_number.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_number.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesNumber. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_object.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_object.py index af87595b3e41..5a8ea94b929b 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_object.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_object.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesObject. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_string.py b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_string.py index 6ab2c91feda9..8436a1e345b0 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_string.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/additional_properties_string.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesString. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/animal.py b/samples/client/petstore/python-asyncio/petstore_api/models/animal.py index b338e0eb18e9..eef35ab093ab 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/animal.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/animal.py @@ -78,7 +78,7 @@ def class_name(self, class_name): :param class_name: The class_name of this Animal. # noqa: E501 - :type: str + :type class_name: str """ if self.local_vars_configuration.client_side_validation and class_name is None: # noqa: E501 raise ValueError("Invalid value for `class_name`, must not be `None`") # noqa: E501 @@ -101,7 +101,7 @@ def color(self, color): :param color: The color of this Animal. # noqa: E501 - :type: str + :type color: str """ self._color = color diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/api_response.py b/samples/client/petstore/python-asyncio/petstore_api/models/api_response.py index 24e80d02aea4..8cb64673c354 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/api_response.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/api_response.py @@ -78,7 +78,7 @@ def code(self, code): :param code: The code of this ApiResponse. # noqa: E501 - :type: int + :type code: int """ self._code = code @@ -99,7 +99,7 @@ def type(self, type): :param type: The type of this ApiResponse. # noqa: E501 - :type: str + :type type: str """ self._type = type @@ -120,7 +120,7 @@ def message(self, message): :param message: The message of this ApiResponse. # noqa: E501 - :type: str + :type message: str """ self._message = message diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/array_of_array_of_number_only.py b/samples/client/petstore/python-asyncio/petstore_api/models/array_of_array_of_number_only.py index 1f654452077f..41a689c534ac 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/array_of_array_of_number_only.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/array_of_array_of_number_only.py @@ -68,7 +68,7 @@ def array_array_number(self, array_array_number): :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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/array_of_number_only.py b/samples/client/petstore/python-asyncio/petstore_api/models/array_of_number_only.py index 27ba1f58e31e..ddb7f7c7abe0 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/array_of_number_only.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/array_of_number_only.py @@ -68,7 +68,7 @@ def array_number(self, array_number): :param array_number: The array_number of this ArrayOfNumberOnly. # noqa: E501 - :type: list[float] + :type array_number: list[float] """ self._array_number = array_number diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/array_test.py b/samples/client/petstore/python-asyncio/petstore_api/models/array_test.py index f34a372f6f3b..e8e5c378f98e 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/array_test.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/array_test.py @@ -78,7 +78,7 @@ def array_of_string(self, array_of_string): :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 @@ def array_array_of_integer(self, array_array_of_integer): :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 @@ def array_array_of_model(self, array_array_of_model): :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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/big_cat.py b/samples/client/petstore/python-asyncio/petstore_api/models/big_cat.py index fe52c3650ac5..946981f5b7fa 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/big_cat.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/big_cat.py @@ -68,7 +68,7 @@ def kind(self, kind): :param kind: The kind of this BigCat. # noqa: E501 - :type: str + :type kind: str """ allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501 if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/big_cat_all_of.py b/samples/client/petstore/python-asyncio/petstore_api/models/big_cat_all_of.py index b75500db987e..41c205d2576f 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/big_cat_all_of.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/big_cat_all_of.py @@ -68,7 +68,7 @@ def kind(self, kind): :param kind: The kind of this BigCatAllOf. # noqa: E501 - :type: str + :type kind: str """ allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501 if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/capitalization.py b/samples/client/petstore/python-asyncio/petstore_api/models/capitalization.py index cef34c5f6dc3..967d324a0ab0 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/capitalization.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/capitalization.py @@ -93,7 +93,7 @@ def small_camel(self, small_camel): :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 @@ def capital_camel(self, capital_camel): :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 @@ def small_snake(self, small_snake): :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 @@ def capital_snake(self, capital_snake): :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 @@ def sca_eth_flow_points(self, sca_eth_flow_points): :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 @@ def att_name(self, att_name): 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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/cat.py b/samples/client/petstore/python-asyncio/petstore_api/models/cat.py index e39c1c82508c..b3b0d868c7f0 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/cat.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/cat.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this Cat. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/cat_all_of.py b/samples/client/petstore/python-asyncio/petstore_api/models/cat_all_of.py index 7e90fab93489..f573a04636c1 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/cat_all_of.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/cat_all_of.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this CatAllOf. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/category.py b/samples/client/petstore/python-asyncio/petstore_api/models/category.py index b47c148953ea..11a7bf85f3ad 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/category.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/category.py @@ -72,7 +72,7 @@ def id(self, id): :param id: The id of this Category. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -93,7 +93,7 @@ def name(self, name): :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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/class_model.py b/samples/client/petstore/python-asyncio/petstore_api/models/class_model.py index ef6060ffa70d..aac505ea064d 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/class_model.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/class_model.py @@ -68,7 +68,7 @@ def _class(self, _class): :param _class: The _class of this ClassModel. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/client.py b/samples/client/petstore/python-asyncio/petstore_api/models/client.py index ee5dbf1c43a1..2006350b2109 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/client.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/client.py @@ -68,7 +68,7 @@ def client(self, client): :param client: The client of this Client. # noqa: E501 - :type: str + :type client: str """ self._client = client diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/dog.py b/samples/client/petstore/python-asyncio/petstore_api/models/dog.py index eacb63eedb09..fb9024d0bb76 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/dog.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/dog.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this Dog. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/dog_all_of.py b/samples/client/petstore/python-asyncio/petstore_api/models/dog_all_of.py index 48e048557085..5943ba900dd6 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/dog_all_of.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/dog_all_of.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this DogAllOf. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/enum_arrays.py b/samples/client/petstore/python-asyncio/petstore_api/models/enum_arrays.py index 819ff322157d..ae2ea1d42511 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/enum_arrays.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/enum_arrays.py @@ -73,7 +73,7 @@ def just_symbol(self, just_symbol): :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 @@ def array_enum(self, array_enum): :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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/enum_test.py b/samples/client/petstore/python-asyncio/petstore_api/models/enum_test.py index 464281b3ec0e..e9872c4d005a 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/enum_test.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/enum_test.py @@ -87,7 +87,7 @@ def enum_string(self, enum_string): :param enum_string: The enum_string of this EnumTest. # noqa: E501 - :type: str + :type enum_string: str """ allowed_values = ["UPPER", "lower", ""] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_string not in allowed_values: # noqa: E501 @@ -114,7 +114,7 @@ def enum_string_required(self, enum_string_required): :param enum_string_required: The enum_string_required of this EnumTest. # noqa: E501 - :type: str + :type enum_string_required: str """ if self.local_vars_configuration.client_side_validation and enum_string_required is None: # noqa: E501 raise ValueError("Invalid value for `enum_string_required`, must not be `None`") # noqa: E501 @@ -143,7 +143,7 @@ def enum_integer(self, enum_integer): :param enum_integer: The enum_integer of this EnumTest. # noqa: E501 - :type: int + :type enum_integer: int """ allowed_values = [1, -1] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_integer not in allowed_values: # noqa: E501 @@ -170,7 +170,7 @@ def enum_number(self, enum_number): :param enum_number: The enum_number of this EnumTest. # noqa: E501 - :type: float + :type enum_number: float """ allowed_values = [1.1, -1.2] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_number not in allowed_values: # noqa: E501 @@ -197,7 +197,7 @@ def outer_enum(self, outer_enum): :param outer_enum: The outer_enum of this EnumTest. # noqa: E501 - :type: OuterEnum + :type outer_enum: OuterEnum """ self._outer_enum = outer_enum diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/file.py b/samples/client/petstore/python-asyncio/petstore_api/models/file.py index 282df2957e67..4fb5c31762e8 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/file.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/file.py @@ -70,7 +70,7 @@ def source_uri(self, source_uri): 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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/file_schema_test_class.py b/samples/client/petstore/python-asyncio/petstore_api/models/file_schema_test_class.py index de7f865b47e2..2f2d44a7b33d 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/file_schema_test_class.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/file_schema_test_class.py @@ -73,7 +73,7 @@ def file(self, file): :param file: The file of this FileSchemaTestClass. # noqa: E501 - :type: File + :type file: File """ self._file = file @@ -94,7 +94,7 @@ def files(self, files): :param files: The files of this FileSchemaTestClass. # noqa: E501 - :type: list[File] + :type files: list[File] """ self._files = files diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/format_test.py b/samples/client/petstore/python-asyncio/petstore_api/models/format_test.py index 6396c442f624..c96f8132fa61 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/format_test.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/format_test.py @@ -129,7 +129,7 @@ def integer(self, integer): :param integer: The integer of this FormatTest. # noqa: E501 - :type: int + :type integer: int """ if (self.local_vars_configuration.client_side_validation and integer is not None and integer > 100): # noqa: E501 @@ -156,7 +156,7 @@ def int32(self, int32): :param int32: The int32 of this FormatTest. # noqa: E501 - :type: int + :type int32: int """ if (self.local_vars_configuration.client_side_validation and int32 is not None and int32 > 200): # noqa: E501 @@ -183,7 +183,7 @@ def int64(self, int64): :param int64: The int64 of this FormatTest. # noqa: E501 - :type: int + :type int64: int """ self._int64 = int64 @@ -204,7 +204,7 @@ def number(self, number): :param number: The number of this FormatTest. # noqa: E501 - :type: float + :type number: float """ if self.local_vars_configuration.client_side_validation and number is None: # noqa: E501 raise ValueError("Invalid value for `number`, must not be `None`") # noqa: E501 @@ -233,7 +233,7 @@ def float(self, float): :param float: The float of this FormatTest. # noqa: E501 - :type: float + :type float: float """ if (self.local_vars_configuration.client_side_validation and float is not None and float > 987.6): # noqa: E501 @@ -260,7 +260,7 @@ def double(self, double): :param double: The double of this FormatTest. # noqa: E501 - :type: float + :type double: float """ if (self.local_vars_configuration.client_side_validation and double is not None and double > 123.4): # noqa: E501 @@ -287,7 +287,7 @@ def string(self, string): :param string: The string of this FormatTest. # noqa: E501 - :type: str + :type string: str """ if (self.local_vars_configuration.client_side_validation and string is not None and not re.search(r'[a-z]', string, flags=re.IGNORECASE)): # noqa: E501 @@ -311,7 +311,7 @@ def byte(self, byte): :param byte: The byte of this FormatTest. # noqa: E501 - :type: str + :type byte: str """ if self.local_vars_configuration.client_side_validation and byte is None: # noqa: E501 raise ValueError("Invalid value for `byte`, must not be `None`") # noqa: E501 @@ -337,7 +337,7 @@ def binary(self, binary): :param binary: The binary of this FormatTest. # noqa: E501 - :type: file + :type binary: file """ self._binary = binary @@ -358,7 +358,7 @@ def date(self, date): :param date: The date of this FormatTest. # noqa: E501 - :type: date + :type date: date """ if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501 raise ValueError("Invalid value for `date`, must not be `None`") # noqa: E501 @@ -381,7 +381,7 @@ def date_time(self, date_time): :param date_time: The date_time of this FormatTest. # noqa: E501 - :type: datetime + :type date_time: datetime """ self._date_time = date_time @@ -402,7 +402,7 @@ def uuid(self, uuid): :param uuid: The uuid of this FormatTest. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -423,7 +423,7 @@ def password(self, password): :param password: The password of this FormatTest. # noqa: E501 - :type: str + :type password: str """ if self.local_vars_configuration.client_side_validation and password is None: # noqa: E501 raise ValueError("Invalid value for `password`, must not be `None`") # noqa: E501 @@ -452,7 +452,7 @@ def big_decimal(self, big_decimal): :param big_decimal: The big_decimal of this FormatTest. # noqa: E501 - :type: BigDecimal + :type big_decimal: BigDecimal """ self._big_decimal = big_decimal diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/has_only_read_only.py b/samples/client/petstore/python-asyncio/petstore_api/models/has_only_read_only.py index 5fc2f8a9ebdd..fa496519ecb2 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/has_only_read_only.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/has_only_read_only.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def foo(self, foo): :param foo: The foo of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type foo: str """ self._foo = foo diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/list.py b/samples/client/petstore/python-asyncio/petstore_api/models/list.py index d58d13e90fbc..e21a220f71cd 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/list.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/list.py @@ -68,7 +68,7 @@ def _123_list(self, _123_list): :param _123_list: The _123_list of this List. # noqa: E501 - :type: str + :type _123_list: str """ self.__123_list = _123_list diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/map_test.py b/samples/client/petstore/python-asyncio/petstore_api/models/map_test.py index f0cfba5073b0..8afc875ce517 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/map_test.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/map_test.py @@ -83,7 +83,7 @@ def map_map_of_string(self, map_map_of_string): :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 @@ def map_of_enum_string(self, map_of_enum_string): :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 @@ def direct_map(self, direct_map): :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 @@ def indirect_map(self, indirect_map): :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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/mixed_properties_and_additional_properties_class.py b/samples/client/petstore/python-asyncio/petstore_api/models/mixed_properties_and_additional_properties_class.py index 5da34f8830e8..8aecbf0f558a 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/mixed_properties_and_additional_properties_class.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/mixed_properties_and_additional_properties_class.py @@ -78,7 +78,7 @@ def uuid(self, uuid): :param uuid: The uuid of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -99,7 +99,7 @@ def date_time(self, date_time): :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 @@ def map(self, map): :param map: The map of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: dict(str, Animal) + :type map: dict(str, Animal) """ self._map = map diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/model200_response.py b/samples/client/petstore/python-asyncio/petstore_api/models/model200_response.py index 841ce1f18f3d..3f4c4e2bd2a7 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/model200_response.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/model200_response.py @@ -73,7 +73,7 @@ def name(self, name): :param name: The name of this Model200Response. # noqa: E501 - :type: int + :type name: int """ self._name = name @@ -94,7 +94,7 @@ def _class(self, _class): :param _class: The _class of this Model200Response. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/model_return.py b/samples/client/petstore/python-asyncio/petstore_api/models/model_return.py index fdd8d72314ad..1009c50ef08e 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/model_return.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/model_return.py @@ -68,7 +68,7 @@ def _return(self, _return): :param _return: The _return of this ModelReturn. # noqa: E501 - :type: int + :type _return: int """ self.__return = _return diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/name.py b/samples/client/petstore/python-asyncio/petstore_api/models/name.py index bb2c1fbd73cc..6ee8261e7821 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/name.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/name.py @@ -82,7 +82,7 @@ def name(self, name): :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 @@ def snake_case(self, snake_case): :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 @@ def _property(self, _property): :param _property: The _property of this Name. # noqa: E501 - :type: str + :type _property: str """ self.__property = _property @@ -147,7 +147,7 @@ def _123_number(self, _123_number): :param _123_number: The _123_number of this Name. # noqa: E501 - :type: int + :type _123_number: int """ self.__123_number = _123_number diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/number_only.py b/samples/client/petstore/python-asyncio/petstore_api/models/number_only.py index 99b2424852fb..90f09d8b7d56 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/number_only.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/number_only.py @@ -68,7 +68,7 @@ def just_number(self, just_number): :param just_number: The just_number of this NumberOnly. # noqa: E501 - :type: float + :type just_number: float """ self._just_number = just_number diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/order.py b/samples/client/petstore/python-asyncio/petstore_api/models/order.py index 8c863cce8fe5..8f298aa3d9c2 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/order.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/order.py @@ -93,7 +93,7 @@ def id(self, id): :param id: The id of this Order. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -114,7 +114,7 @@ def pet_id(self, pet_id): :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 @@ def quantity(self, quantity): :param quantity: The quantity of this Order. # noqa: E501 - :type: int + :type quantity: int """ self._quantity = quantity @@ -156,7 +156,7 @@ def ship_date(self, ship_date): :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 @@ def status(self, status): 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 @@ def complete(self, complete): :param complete: The complete of this Order. # noqa: E501 - :type: bool + :type complete: bool """ self._complete = complete diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/outer_composite.py b/samples/client/petstore/python-asyncio/petstore_api/models/outer_composite.py index c11859114a57..85fe36c7ef07 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/outer_composite.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/outer_composite.py @@ -78,7 +78,7 @@ def my_number(self, my_number): :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 @@ def my_string(self, my_string): :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 @@ def my_boolean(self, my_boolean): :param my_boolean: The my_boolean of this OuterComposite. # noqa: E501 - :type: bool + :type my_boolean: bool """ self._my_boolean = my_boolean diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/pet.py b/samples/client/petstore/python-asyncio/petstore_api/models/pet.py index edbf73f53127..b948a6436db1 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/pet.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/pet.py @@ -91,7 +91,7 @@ def id(self, id): :param id: The id of this Pet. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -112,7 +112,7 @@ def category(self, category): :param category: The category of this Pet. # noqa: E501 - :type: Category + :type category: Category """ self._category = category @@ -133,7 +133,7 @@ def name(self, name): :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 @@ def photo_urls(self, photo_urls): :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 @@ def tags(self, tags): :param tags: The tags of this Pet. # noqa: E501 - :type: list[Tag] + :type tags: list[Tag] """ self._tags = tags @@ -202,7 +202,7 @@ def status(self, status): 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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/read_only_first.py b/samples/client/petstore/python-asyncio/petstore_api/models/read_only_first.py index a84679e98dee..3a305087dc26 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/read_only_first.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/read_only_first.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this ReadOnlyFirst. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def baz(self, baz): :param baz: The baz of this ReadOnlyFirst. # noqa: E501 - :type: str + :type baz: str """ self._baz = baz diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/special_model_name.py b/samples/client/petstore/python-asyncio/petstore_api/models/special_model_name.py index 396e75bcee5c..d2535eb65aca 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/special_model_name.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/special_model_name.py @@ -68,7 +68,7 @@ def special_property_name(self, special_property_name): :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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/tag.py b/samples/client/petstore/python-asyncio/petstore_api/models/tag.py index d6137fdd47f0..7492d30d9eb6 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/tag.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/tag.py @@ -73,7 +73,7 @@ def id(self, id): :param id: The id of this Tag. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -94,7 +94,7 @@ def name(self, name): :param name: The name of this Tag. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_default.py b/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_default.py index 8163ea77aa73..fbef6b4b1574 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_default.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_default.py @@ -83,7 +83,7 @@ def string_item(self, string_item): :param string_item: The string_item of this TypeHolderDefault. # noqa: E501 - :type: str + :type string_item: str """ if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501 raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501 @@ -106,7 +106,7 @@ def number_item(self, number_item): :param number_item: The number_item of this TypeHolderDefault. # noqa: E501 - :type: float + :type number_item: float """ if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501 raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501 @@ -129,7 +129,7 @@ def integer_item(self, integer_item): :param integer_item: The integer_item of this TypeHolderDefault. # noqa: E501 - :type: int + :type integer_item: int """ if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501 raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501 @@ -152,7 +152,7 @@ def bool_item(self, bool_item): :param bool_item: The bool_item of this TypeHolderDefault. # noqa: E501 - :type: bool + :type bool_item: bool """ if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501 raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501 @@ -175,7 +175,7 @@ def array_item(self, array_item): :param array_item: The array_item of this TypeHolderDefault. # noqa: E501 - :type: list[int] + :type array_item: list[int] """ if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501 raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_example.py b/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_example.py index 34481fd21e31..b7320bed0ca7 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_example.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/type_holder_example.py @@ -87,7 +87,7 @@ def string_item(self, string_item): :param string_item: The string_item of this TypeHolderExample. # noqa: E501 - :type: str + :type string_item: str """ if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501 raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501 @@ -110,7 +110,7 @@ def number_item(self, number_item): :param number_item: The number_item of this TypeHolderExample. # noqa: E501 - :type: float + :type number_item: float """ if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501 raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501 @@ -133,7 +133,7 @@ def float_item(self, float_item): :param float_item: The float_item of this TypeHolderExample. # noqa: E501 - :type: float + :type float_item: float """ if self.local_vars_configuration.client_side_validation and float_item is None: # noqa: E501 raise ValueError("Invalid value for `float_item`, must not be `None`") # noqa: E501 @@ -156,7 +156,7 @@ def integer_item(self, integer_item): :param integer_item: The integer_item of this TypeHolderExample. # noqa: E501 - :type: int + :type integer_item: int """ if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501 raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501 @@ -179,7 +179,7 @@ def bool_item(self, bool_item): :param bool_item: The bool_item of this TypeHolderExample. # noqa: E501 - :type: bool + :type bool_item: bool """ if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501 raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501 @@ -202,7 +202,7 @@ def array_item(self, array_item): :param array_item: The array_item of this TypeHolderExample. # noqa: E501 - :type: list[int] + :type array_item: list[int] """ if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501 raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/user.py b/samples/client/petstore/python-asyncio/petstore_api/models/user.py index de88bda4cde7..0e25f9f17104 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/user.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/user.py @@ -103,7 +103,7 @@ def id(self, id): :param id: The id of this User. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -124,7 +124,7 @@ def username(self, username): :param username: The username of this User. # noqa: E501 - :type: str + :type username: str """ self._username = username @@ -145,7 +145,7 @@ def first_name(self, first_name): :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 @@ def last_name(self, last_name): :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 @@ def email(self, email): :param email: The email of this User. # noqa: E501 - :type: str + :type email: str """ self._email = email @@ -208,7 +208,7 @@ def password(self, password): :param password: The password of this User. # noqa: E501 - :type: str + :type password: str """ self._password = password @@ -229,7 +229,7 @@ def phone(self, phone): :param phone: The phone of this User. # noqa: E501 - :type: str + :type phone: str """ self._phone = phone @@ -252,7 +252,7 @@ def user_status(self, user_status): 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 diff --git a/samples/client/petstore/python-asyncio/petstore_api/models/xml_item.py b/samples/client/petstore/python-asyncio/petstore_api/models/xml_item.py index 52ecc9aa5225..afb75967cb0b 100644 --- a/samples/client/petstore/python-asyncio/petstore_api/models/xml_item.py +++ b/samples/client/petstore/python-asyncio/petstore_api/models/xml_item.py @@ -208,7 +208,7 @@ def attribute_string(self, attribute_string): :param attribute_string: The attribute_string of this XmlItem. # noqa: E501 - :type: str + :type attribute_string: str """ self._attribute_string = attribute_string @@ -229,7 +229,7 @@ def attribute_number(self, attribute_number): :param attribute_number: The attribute_number of this XmlItem. # noqa: E501 - :type: float + :type attribute_number: float """ self._attribute_number = attribute_number @@ -250,7 +250,7 @@ def attribute_integer(self, attribute_integer): :param attribute_integer: The attribute_integer of this XmlItem. # noqa: E501 - :type: int + :type attribute_integer: int """ self._attribute_integer = attribute_integer @@ -271,7 +271,7 @@ def attribute_boolean(self, attribute_boolean): :param attribute_boolean: The attribute_boolean of this XmlItem. # noqa: E501 - :type: bool + :type attribute_boolean: bool """ self._attribute_boolean = attribute_boolean @@ -292,7 +292,7 @@ def wrapped_array(self, wrapped_array): :param wrapped_array: The wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type wrapped_array: list[int] """ self._wrapped_array = wrapped_array @@ -313,7 +313,7 @@ def name_string(self, name_string): :param name_string: The name_string of this XmlItem. # noqa: E501 - :type: str + :type name_string: str """ self._name_string = name_string @@ -334,7 +334,7 @@ def name_number(self, name_number): :param name_number: The name_number of this XmlItem. # noqa: E501 - :type: float + :type name_number: float """ self._name_number = name_number @@ -355,7 +355,7 @@ def name_integer(self, name_integer): :param name_integer: The name_integer of this XmlItem. # noqa: E501 - :type: int + :type name_integer: int """ self._name_integer = name_integer @@ -376,7 +376,7 @@ def name_boolean(self, name_boolean): :param name_boolean: The name_boolean of this XmlItem. # noqa: E501 - :type: bool + :type name_boolean: bool """ self._name_boolean = name_boolean @@ -397,7 +397,7 @@ def name_array(self, name_array): :param name_array: The name_array of this XmlItem. # noqa: E501 - :type: list[int] + :type name_array: list[int] """ self._name_array = name_array @@ -418,7 +418,7 @@ def name_wrapped_array(self, name_wrapped_array): :param name_wrapped_array: The name_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type name_wrapped_array: list[int] """ self._name_wrapped_array = name_wrapped_array @@ -439,7 +439,7 @@ def prefix_string(self, prefix_string): :param prefix_string: The prefix_string of this XmlItem. # noqa: E501 - :type: str + :type prefix_string: str """ self._prefix_string = prefix_string @@ -460,7 +460,7 @@ def prefix_number(self, prefix_number): :param prefix_number: The prefix_number of this XmlItem. # noqa: E501 - :type: float + :type prefix_number: float """ self._prefix_number = prefix_number @@ -481,7 +481,7 @@ def prefix_integer(self, prefix_integer): :param prefix_integer: The prefix_integer of this XmlItem. # noqa: E501 - :type: int + :type prefix_integer: int """ self._prefix_integer = prefix_integer @@ -502,7 +502,7 @@ def prefix_boolean(self, prefix_boolean): :param prefix_boolean: The prefix_boolean of this XmlItem. # noqa: E501 - :type: bool + :type prefix_boolean: bool """ self._prefix_boolean = prefix_boolean @@ -523,7 +523,7 @@ def prefix_array(self, prefix_array): :param prefix_array: The prefix_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_array: list[int] """ self._prefix_array = prefix_array @@ -544,7 +544,7 @@ def prefix_wrapped_array(self, prefix_wrapped_array): :param prefix_wrapped_array: The prefix_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_wrapped_array: list[int] """ self._prefix_wrapped_array = prefix_wrapped_array @@ -565,7 +565,7 @@ def namespace_string(self, namespace_string): :param namespace_string: The namespace_string of this XmlItem. # noqa: E501 - :type: str + :type namespace_string: str """ self._namespace_string = namespace_string @@ -586,7 +586,7 @@ def namespace_number(self, namespace_number): :param namespace_number: The namespace_number of this XmlItem. # noqa: E501 - :type: float + :type namespace_number: float """ self._namespace_number = namespace_number @@ -607,7 +607,7 @@ def namespace_integer(self, namespace_integer): :param namespace_integer: The namespace_integer of this XmlItem. # noqa: E501 - :type: int + :type namespace_integer: int """ self._namespace_integer = namespace_integer @@ -628,7 +628,7 @@ def namespace_boolean(self, namespace_boolean): :param namespace_boolean: The namespace_boolean of this XmlItem. # noqa: E501 - :type: bool + :type namespace_boolean: bool """ self._namespace_boolean = namespace_boolean @@ -649,7 +649,7 @@ def namespace_array(self, namespace_array): :param namespace_array: The namespace_array of this XmlItem. # noqa: E501 - :type: list[int] + :type namespace_array: list[int] """ self._namespace_array = namespace_array @@ -670,7 +670,7 @@ def namespace_wrapped_array(self, namespace_wrapped_array): :param namespace_wrapped_array: The namespace_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type namespace_wrapped_array: list[int] """ self._namespace_wrapped_array = namespace_wrapped_array @@ -691,7 +691,7 @@ def prefix_ns_string(self, prefix_ns_string): :param prefix_ns_string: The prefix_ns_string of this XmlItem. # noqa: E501 - :type: str + :type prefix_ns_string: str """ self._prefix_ns_string = prefix_ns_string @@ -712,7 +712,7 @@ def prefix_ns_number(self, prefix_ns_number): :param prefix_ns_number: The prefix_ns_number of this XmlItem. # noqa: E501 - :type: float + :type prefix_ns_number: float """ self._prefix_ns_number = prefix_ns_number @@ -733,7 +733,7 @@ def prefix_ns_integer(self, prefix_ns_integer): :param prefix_ns_integer: The prefix_ns_integer of this XmlItem. # noqa: E501 - :type: int + :type prefix_ns_integer: int """ self._prefix_ns_integer = prefix_ns_integer @@ -754,7 +754,7 @@ def prefix_ns_boolean(self, prefix_ns_boolean): :param prefix_ns_boolean: The prefix_ns_boolean of this XmlItem. # noqa: E501 - :type: bool + :type prefix_ns_boolean: bool """ self._prefix_ns_boolean = prefix_ns_boolean @@ -775,7 +775,7 @@ def prefix_ns_array(self, prefix_ns_array): :param prefix_ns_array: The prefix_ns_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_ns_array: list[int] """ self._prefix_ns_array = prefix_ns_array @@ -796,7 +796,7 @@ def prefix_ns_wrapped_array(self, prefix_ns_wrapped_array): :param prefix_ns_wrapped_array: The prefix_ns_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_ns_wrapped_array: list[int] """ self._prefix_ns_wrapped_array = prefix_ns_wrapped_array diff --git a/samples/client/petstore/python-experimental/petstore_api/api/another_fake_api.py b/samples/client/petstore/python-experimental/petstore_api/api/another_fake_api.py index 3f277311b8fb..49f603489978 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api/another_fake_api.py +++ b/samples/client/petstore/python-experimental/petstore_api/api/another_fake_api.py @@ -59,6 +59,7 @@ def __call_123_test_special_tags( To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags(body, async_req=True) >>> result = thread.get() diff --git a/samples/client/petstore/python-experimental/petstore_api/api/fake_api.py b/samples/client/petstore/python-experimental/petstore_api/api/fake_api.py index a05c8e947b31..3f2e1ae4bd94 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api/fake_api.py +++ b/samples/client/petstore/python-experimental/petstore_api/api/fake_api.py @@ -65,6 +65,7 @@ def __create_xml_item( this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item(xml_item, async_req=True) >>> result = thread.get() @@ -184,6 +185,7 @@ def __fake_outer_boolean_serialize( Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize(async_req=True) >>> result = thread.get() @@ -293,6 +295,7 @@ def __fake_outer_composite_serialize( Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize(async_req=True) >>> result = thread.get() @@ -402,6 +405,7 @@ def __fake_outer_enum_serialize( Test serialization of outer enum # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_enum_serialize(async_req=True) >>> result = thread.get() @@ -511,6 +515,7 @@ def __fake_outer_number_serialize( Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize(async_req=True) >>> result = thread.get() @@ -620,6 +625,7 @@ def __fake_outer_string_serialize( Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize(async_req=True) >>> result = thread.get() @@ -730,6 +736,7 @@ def __test_body_with_file_schema( For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema(body, async_req=True) >>> result = thread.get() @@ -845,6 +852,7 @@ def __test_body_with_query_params( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params(query, body, async_req=True) >>> result = thread.get() @@ -969,6 +977,7 @@ def __test_client_model( To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model(body, async_req=True) >>> result = thread.get() @@ -1090,6 +1099,7 @@ def __test_endpoint_enums_length_one( This route has required values with enums of 1 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_enums_length_one(query_integer=3, query_string='brillig', path_string='hello', path_integer=34, header_number=1.234, async_req=True) >>> result = thread.get() @@ -1268,6 +1278,7 @@ def __test_endpoint_parameters( Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() @@ -1521,6 +1532,7 @@ def __test_enum_parameters( To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters(async_req=True) >>> result = thread.get() @@ -1730,6 +1742,7 @@ def __test_group_parameters( Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() @@ -1879,6 +1892,7 @@ def __test_inline_additional_properties( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties(param, async_req=True) >>> result = thread.get() @@ -1994,6 +2008,7 @@ def __test_json_form_data( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_json_form_data(param, param2, async_req=True) >>> result = thread.get() diff --git a/samples/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py b/samples/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py index be57432ae68d..22b66a6a6c00 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py +++ b/samples/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py @@ -59,6 +59,7 @@ def __test_classname( To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname(body, async_req=True) >>> result = thread.get() diff --git a/samples/client/petstore/python-experimental/petstore_api/api/pet_api.py b/samples/client/petstore/python-experimental/petstore_api/api/pet_api.py index 6ec1e6d5c5cd..d917cb3cd678 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api/pet_api.py +++ b/samples/client/petstore/python-experimental/petstore_api/api/pet_api.py @@ -59,6 +59,7 @@ def __add_pet( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet(body, async_req=True) >>> result = thread.get() @@ -176,6 +177,7 @@ def __delete_pet( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_pet(pet_id, async_req=True) >>> result = thread.get() @@ -298,6 +300,7 @@ def __find_pets_by_status( Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status(status, async_req=True) >>> result = thread.get() @@ -425,6 +428,7 @@ def __find_pets_by_tags( Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags(tags, async_req=True) >>> result = thread.get() @@ -545,6 +549,7 @@ def __get_pet_by_id( Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id(pet_id, async_req=True) >>> result = thread.get() @@ -663,6 +668,7 @@ def __update_pet( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_pet(body, async_req=True) >>> result = thread.get() @@ -780,6 +786,7 @@ def __update_pet_with_form( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_pet_with_form(pet_id, async_req=True) >>> result = thread.get() @@ -909,6 +916,7 @@ def __upload_file( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file(pet_id, async_req=True) >>> result = thread.get() @@ -1048,6 +1056,7 @@ def __upload_file_with_required_file( 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() diff --git a/samples/client/petstore/python-experimental/petstore_api/api/store_api.py b/samples/client/petstore/python-experimental/petstore_api/api/store_api.py index e612a43704f2..bd4c0e0a25ee 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api/store_api.py +++ b/samples/client/petstore/python-experimental/petstore_api/api/store_api.py @@ -59,6 +59,7 @@ def __delete_order( For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_order(order_id, async_req=True) >>> result = thread.get() @@ -172,6 +173,7 @@ def __get_inventory( Returns a map of status codes to quantities # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_inventory(async_req=True) >>> result = thread.get() @@ -279,6 +281,7 @@ def __get_order_by_id( For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_order_by_id(order_id, async_req=True) >>> result = thread.get() @@ -401,6 +404,7 @@ def __place_order( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order(body, async_req=True) >>> result = thread.get() diff --git a/samples/client/petstore/python-experimental/petstore_api/api/user_api.py b/samples/client/petstore/python-experimental/petstore_api/api/user_api.py index 930ae821f2cb..f313a2303546 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api/user_api.py +++ b/samples/client/petstore/python-experimental/petstore_api/api/user_api.py @@ -59,6 +59,7 @@ def __create_user( This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user(body, async_req=True) >>> result = thread.get() @@ -171,6 +172,7 @@ def __create_users_with_array_input( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_array_input(body, async_req=True) >>> result = thread.get() @@ -283,6 +285,7 @@ def __create_users_with_list_input( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_list_input(body, async_req=True) >>> result = thread.get() @@ -396,6 +399,7 @@ def __delete_user( This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user(username, async_req=True) >>> result = thread.get() @@ -509,6 +513,7 @@ def __get_user_by_name( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_user_by_name(username, async_req=True) >>> result = thread.get() @@ -626,6 +631,7 @@ def __login_user( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user(username, password, async_req=True) >>> result = thread.get() @@ -750,6 +756,7 @@ def __logout_user( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user(async_req=True) >>> result = thread.get() @@ -854,6 +861,7 @@ def __update_user( This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user(username, body, async_req=True) >>> result = thread.get() diff --git a/samples/client/petstore/python-experimental/petstore_api/api_client.py b/samples/client/petstore/python-experimental/petstore_api/api_client.py index 398333268183..58430c7459e9 100644 --- a/samples/client/petstore/python-experimental/petstore_api/api_client.py +++ b/samples/client/petstore/python-experimental/petstore_api/api_client.py @@ -279,6 +279,7 @@ def deserialize(self, response, response_type, _check_type): ({str: (bool, str, int, float, date, datetime, str, none_type)},) :param _check_type: boolean, whether to check the types of the data received from the server + :type _check_type: bool :return: deserialized object. """ @@ -338,22 +339,28 @@ def call_api(self, resource_path, method, (float, none_type) ([int, none_type],) ({str: (bool, str, int, float, date, datetime, str, none_type)},) - :param files dict: key -> field name, value -> a list of open file + :param files: key -> field name, value -> a list of open file objects for `multipart/form-data`. + :type files: dict :param async_req bool: execute request asynchronously + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param collection_formats: dict of collection formats for path, query, header, and post parameters. + :type collection_formats: dict, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _check_type: boolean describing if the data back from the server should have its type checked. + :type _check_type: bool, optional :return: If async_req parameter is True, the request will be called asynchronously. @@ -547,9 +554,9 @@ def update_params_for_auth(self, headers, querys, auth_settings, :param headers: Header parameters dict to be updated. :param querys: Query parameters tuple list to be updated. :param auth_settings: Authentication setting identifiers list. - :resource_path: A string representation of the HTTP request resource path. - :method: A string representation of the HTTP request method. - :body: A object representing the body of the HTTP request. + :param resource_path: A string representation of the HTTP request resource path. + :param method: A string representation of the HTTP request method. + :param body: A object representing the body of the HTTP request. The object type is the return value of sanitize_for_serialization(). """ if not auth_settings: diff --git a/samples/client/petstore/python-tornado/petstore_api/api/another_fake_api.py b/samples/client/petstore/python-tornado/petstore_api/api/another_fake_api.py index 77c4c003fe4e..4d69b287ca8b 100644 --- a/samples/client/petstore/python-tornado/petstore_api/api/another_fake_api.py +++ b/samples/client/petstore/python-tornado/petstore_api/api/another_fake_api.py @@ -42,21 +42,26 @@ def call_123_test_special_tags(self, body, **kwargs): # noqa: E501 To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.call_123_test_special_tags_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def call_123_test_special_tags_with_http_info(self, body, **kwargs): # noqa: E5 To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python-tornado/petstore_api/api/fake_api.py b/samples/client/petstore/python-tornado/petstore_api/api/fake_api.py index 667c50612ce6..e1d9ffebebfe 100644 --- a/samples/client/petstore/python-tornado/petstore_api/api/fake_api.py +++ b/samples/client/petstore/python-tornado/petstore_api/api/fake_api.py @@ -42,21 +42,26 @@ def create_xml_item(self, xml_item, **kwargs): # noqa: E501 this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item(xml_item, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param XmlItem xml_item: XmlItem Body (required) + :param xml_item: XmlItem Body (required) + :type xml_item: XmlItem + :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_xml_item_with_http_info(xml_item, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def create_xml_item_with_http_info(self, xml_item, **kwargs): # noqa: E501 this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item_with_http_info(xml_item, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param XmlItem xml_item: XmlItem Body (required) + :param xml_item: XmlItem Body (required) + :type xml_item: XmlItem + :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() @@ -156,21 +167,26 @@ def fake_outer_boolean_serialize(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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: bool + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: bool """ kwargs['_return_http_data_only'] = True return self.fake_outer_boolean_serialize_with_http_info(**kwargs) # noqa: E501 @@ -181,23 +197,29 @@ def fake_outer_boolean_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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(bool, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(bool, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -266,21 +288,26 @@ def fake_outer_composite_serialize(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite body: Input composite as post body + :param body: Input composite as post body + :type body: OuterComposite + :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: OuterComposite + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: OuterComposite """ kwargs['_return_http_data_only'] = True return self.fake_outer_composite_serialize_with_http_info(**kwargs) # noqa: E501 @@ -291,23 +318,29 @@ def fake_outer_composite_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite body: Input composite as post body + :param body: Input composite as post body + :type body: OuterComposite + :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(OuterComposite, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(OuterComposite, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -376,21 +409,26 @@ def fake_outer_number_serialize(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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: float + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: float """ kwargs['_return_http_data_only'] = True return self.fake_outer_number_serialize_with_http_info(**kwargs) # noqa: E501 @@ -401,23 +439,29 @@ def fake_outer_number_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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(float, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(float, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -486,21 +530,26 @@ def fake_outer_string_serialize(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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.fake_outer_string_serialize_with_http_info(**kwargs) # noqa: E501 @@ -511,23 +560,29 @@ def fake_outer_string_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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() @@ -596,21 +651,26 @@ def test_body_with_file_schema(self, body, **kwargs): # noqa: E501 For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass body: (required) + :param body: (required) + :type body: FileSchemaTestClass + :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.test_body_with_file_schema_with_http_info(body, **kwargs) # noqa: E501 @@ -621,23 +681,29 @@ def test_body_with_file_schema_with_http_info(self, body, **kwargs): # noqa: E5 For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass body: (required) + :param body: (required) + :type body: FileSchemaTestClass + :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() @@ -709,22 +775,28 @@ def test_body_with_query_params(self, query, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params(query, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User body: (required) + :param query: (required) + :type query: str + :param body: (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.test_body_with_query_params_with_http_info(query, body, **kwargs) # noqa: E501 @@ -734,24 +806,31 @@ def test_body_with_query_params_with_http_info(self, query, body, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params_with_http_info(query, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User body: (required) + :param query: (required) + :type query: str + :param body: (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -831,21 +910,26 @@ def test_client_model(self, body, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.test_client_model_with_http_info(body, **kwargs) # noqa: E501 @@ -856,23 +940,29 @@ def test_client_model_with_http_info(self, body, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -949,34 +1039,52 @@ def test_endpoint_parameters(self, number, double, pattern_without_delimiter, by Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, **kwargs) # noqa: E501 @@ -987,36 +1095,55 @@ def test_endpoint_parameters_with_http_info(self, number, double, pattern_withou Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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() @@ -1168,28 +1295,40 @@ def test_enum_parameters(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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.test_enum_parameters_with_http_info(**kwargs) # noqa: E501 @@ -1200,30 +1339,43 @@ def test_enum_parameters_with_http_info(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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() @@ -1316,26 +1468,36 @@ def test_group_parameters(self, required_string_group, required_boolean_group, r Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: 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.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, **kwargs) # noqa: E501 @@ -1346,28 +1508,39 @@ def test_group_parameters_with_http_info(self, required_string_group, required_b Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -1458,21 +1631,26 @@ def test_inline_additional_properties(self, param, **kwargs): # 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_inline_additional_properties(param, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) param: request body (required) + :param param: request body (required) + :type param: dict(str, 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.test_inline_additional_properties_with_http_info(param, **kwargs) # noqa: E501 @@ -1482,23 +1660,29 @@ def test_inline_additional_properties_with_http_info(self, param, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties_with_http_info(param, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) param: request body (required) + :param param: request body (required) + :type param: dict(str, 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() @@ -1570,22 +1754,28 @@ def test_json_form_data(self, param, param2, **kwargs): # 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_json_form_data(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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.test_json_form_data_with_http_info(param, param2, **kwargs) # noqa: E501 @@ -1595,24 +1785,31 @@ def test_json_form_data_with_http_info(self, param, param2, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_json_form_data_with_http_info(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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() @@ -1692,25 +1889,34 @@ def test_query_parameter_collection_format(self, pipe, ioutil, http, url, contex To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: 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.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, **kwargs) # noqa: E501 @@ -1721,27 +1927,37 @@ def test_query_parameter_collection_format_with_http_info(self, pipe, ioutil, ht To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/client/petstore/python-tornado/petstore_api/api/fake_classname_tags_123_api.py b/samples/client/petstore/python-tornado/petstore_api/api/fake_classname_tags_123_api.py index 2bb189bd01b9..d963591a49a8 100644 --- a/samples/client/petstore/python-tornado/petstore_api/api/fake_classname_tags_123_api.py +++ b/samples/client/petstore/python-tornado/petstore_api/api/fake_classname_tags_123_api.py @@ -42,21 +42,26 @@ def test_classname(self, body, **kwargs): # noqa: E501 To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.test_classname_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def test_classname_with_http_info(self, body, **kwargs): # noqa: E501 To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python-tornado/petstore_api/api/pet_api.py b/samples/client/petstore/python-tornado/petstore_api/api/pet_api.py index 5a297a57647b..7002fe32740f 100644 --- a/samples/client/petstore/python-tornado/petstore_api/api/pet_api.py +++ b/samples/client/petstore/python-tornado/petstore_api/api/pet_api.py @@ -41,21 +41,26 @@ def add_pet(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.add_pet_with_http_info(body, **kwargs) # noqa: E501 @@ -65,23 +70,29 @@ def add_pet_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -153,22 +164,28 @@ def delete_pet(self, pet_id, **kwargs): # 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_pet(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: Pet id to delete (required) - :param str api_key: + :param pet_id: Pet id to delete (required) + :type pet_id: int + :param api_key: + :type api_key: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.delete_pet_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -178,24 +195,31 @@ def delete_pet_with_http_info(self, pet_id, **kwargs): # 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_pet_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: Pet id to delete (required) - :param str api_key: + :param pet_id: Pet id to delete (required) + :type pet_id: int + :param api_key: + :type api_key: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -267,21 +291,26 @@ def find_pets_by_status(self, status, **kwargs): # noqa: E501 Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status(status, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] status: Status values that need to be considered for filter (required) + :param status: Status values that need to be considered for filter (required) + :type status: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: list[Pet] + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: list[Pet] """ kwargs['_return_http_data_only'] = True return self.find_pets_by_status_with_http_info(status, **kwargs) # noqa: E501 @@ -292,23 +321,29 @@ def find_pets_by_status_with_http_info(self, status, **kwargs): # noqa: E501 Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status_with_http_info(status, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] status: Status values that need to be considered for filter (required) + :param status: Status values that need to be considered for filter (required) + :type status: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -382,21 +417,26 @@ def find_pets_by_tags(self, tags, **kwargs): # noqa: E501 Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags(tags, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] tags: Tags to filter by (required) + :param tags: Tags to filter by (required) + :type tags: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: list[Pet] + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: list[Pet] """ kwargs['_return_http_data_only'] = True return self.find_pets_by_tags_with_http_info(tags, **kwargs) # noqa: E501 @@ -407,23 +447,29 @@ def find_pets_by_tags_with_http_info(self, tags, **kwargs): # noqa: E501 Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags_with_http_info(tags, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] tags: Tags to filter by (required) + :param tags: Tags to filter by (required) + :type tags: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -497,21 +543,26 @@ def get_pet_by_id(self, pet_id, **kwargs): # noqa: E501 Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to return (required) + :param pet_id: ID of pet to return (required) + :type pet_id: int + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Pet + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Pet """ kwargs['_return_http_data_only'] = True return self.get_pet_by_id_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -522,23 +573,29 @@ def get_pet_by_id_with_http_info(self, pet_id, **kwargs): # noqa: E501 Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to return (required) + :param pet_id: ID of pet to return (required) + :type pet_id: int + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Pet, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Pet, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -610,21 +667,26 @@ def update_pet(self, body, **kwargs): # 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_pet(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_pet_with_http_info(body, **kwargs) # noqa: E501 @@ -634,23 +696,29 @@ def update_pet_with_http_info(self, body, **kwargs): # 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_pet_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -722,23 +790,30 @@ def update_pet_with_form(self, pet_id, **kwargs): # 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_pet_with_form(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet that needs to be updated (required) - :param str name: Updated name of the pet - :param str status: Updated status of the pet + :param pet_id: ID of pet that needs to be updated (required) + :type pet_id: int + :param name: Updated name of the pet + :type name: str + :param status: Updated status of the pet + :type status: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_pet_with_form_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -748,25 +823,33 @@ def update_pet_with_form_with_http_info(self, pet_id, **kwargs): # 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_pet_with_form_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet that needs to be updated (required) - :param str name: Updated name of the pet - :param str status: Updated status of the pet + :param pet_id: ID of pet that needs to be updated (required) + :type pet_id: int + :param name: Updated name of the pet + :type name: str + :param status: Updated status of the pet + :type status: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -844,23 +927,30 @@ def upload_file(self, pet_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param str additional_metadata: Additional data to pass to server - :param file file: file to upload + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param file: file to upload + :type file: file + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiResponse """ kwargs['_return_http_data_only'] = True return self.upload_file_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -870,25 +960,33 @@ def upload_file_with_http_info(self, pet_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param str additional_metadata: Additional data to pass to server - :param file file: file to upload + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param file: file to upload + :type file: file + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -970,23 +1068,30 @@ def upload_file_with_required_file(self, pet_id, required_file, **kwargs): # no This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file_with_required_file(pet_id, required_file, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param file required_file: file to upload (required) - :param str additional_metadata: Additional data to pass to server + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param required_file: file to upload (required) + :type required_file: file + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiResponse """ kwargs['_return_http_data_only'] = True return self.upload_file_with_required_file_with_http_info(pet_id, required_file, **kwargs) # noqa: E501 @@ -996,25 +1101,33 @@ def upload_file_with_required_file_with_http_info(self, pet_id, required_file, * 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() diff --git a/samples/client/petstore/python-tornado/petstore_api/api/store_api.py b/samples/client/petstore/python-tornado/petstore_api/api/store_api.py index f693f755b745..0ede23f05ba2 100644 --- a/samples/client/petstore/python-tornado/petstore_api/api/store_api.py +++ b/samples/client/petstore/python-tornado/petstore_api/api/store_api.py @@ -42,21 +42,26 @@ def delete_order(self, order_id, **kwargs): # noqa: E501 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 @@ def delete_order_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def get_inventory(self, **kwargs): # noqa: E501 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 @@ def get_inventory_with_http_info(self, **kwargs): # noqa: E501 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 @@ def get_order_by_id(self, order_id, **kwargs): # noqa: E501 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 @@ def get_order_by_id_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def place_order(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Order body: order placed for purchasing the pet (required) + :param body: order placed for purchasing the pet (required) + :type body: Order + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Order + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Order """ kwargs['_return_http_data_only'] = True return self.place_order_with_http_info(body, **kwargs) # noqa: E501 @@ -398,23 +434,29 @@ def place_order_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Order body: order placed for purchasing the pet (required) + :param body: order placed for purchasing the pet (required) + :type body: Order + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Order, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python-tornado/petstore_api/api/user_api.py b/samples/client/petstore/python-tornado/petstore_api/api/user_api.py index 9462f00716a3..a912483b023b 100644 --- a/samples/client/petstore/python-tornado/petstore_api/api/user_api.py +++ b/samples/client/petstore/python-tornado/petstore_api/api/user_api.py @@ -42,21 +42,26 @@ def create_user(self, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param User body: Created user object (required) + :param body: Created user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_user_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def create_user_with_http_info(self, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param User body: Created user object (required) + :param body: Created user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -151,21 +162,26 @@ def create_users_with_array_input(self, body, **kwargs): # 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_users_with_array_input(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_users_with_array_input_with_http_info(body, **kwargs) # noqa: E501 @@ -175,23 +191,29 @@ def create_users_with_array_input_with_http_info(self, body, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_array_input_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -259,21 +281,26 @@ def create_users_with_list_input(self, body, **kwargs): # 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_users_with_list_input(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_users_with_list_input_with_http_info(body, **kwargs) # noqa: E501 @@ -283,23 +310,29 @@ def create_users_with_list_input_with_http_info(self, body, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_list_input_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -368,21 +401,26 @@ def delete_user(self, username, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be deleted (required) + :param username: The name that needs to be deleted (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.delete_user_with_http_info(username, **kwargs) # noqa: E501 @@ -393,23 +431,29 @@ def delete_user_with_http_info(self, username, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user_with_http_info(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be deleted (required) + :param username: The name that needs to be deleted (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -477,21 +521,26 @@ def get_user_by_name(self, username, **kwargs): # 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_user_by_name(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be fetched. Use user1 for testing. (required) + :param username: The name that needs to be fetched. Use user1 for testing. (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: User + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: User """ kwargs['_return_http_data_only'] = True return self.get_user_by_name_with_http_info(username, **kwargs) # noqa: E501 @@ -501,23 +550,29 @@ def get_user_by_name_with_http_info(self, username, **kwargs): # 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_user_by_name_with_http_info(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be fetched. Use user1 for testing. (required) + :param username: The name that needs to be fetched. Use user1 for testing. (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(User, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(User, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -589,22 +644,28 @@ def login_user(self, username, password, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user(username, password, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The user name for login (required) - :param str password: The password for login in clear text (required) + :param username: The user name for login (required) + :type username: str + :param password: The password for login in clear text (required) + :type password: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: str + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: str """ kwargs['_return_http_data_only'] = True return self.login_user_with_http_info(username, password, **kwargs) # noqa: E501 @@ -614,24 +675,31 @@ def login_user_with_http_info(self, username, password, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user_with_http_info(username, password, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The user name for login (required) - :param str password: The password for login in clear text (required) + :param username: The user name for login (required) + :type username: str + :param password: The password for login in clear text (required) + :type password: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(str, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(str, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -710,20 +778,24 @@ def logout_user(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.logout_user_with_http_info(**kwargs) # noqa: E501 @@ -733,22 +805,27 @@ def logout_user_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -810,22 +887,28 @@ def update_user(self, username, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user(username, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: name that need to be deleted (required) - :param User body: Updated user object (required) + :param username: name that need to be deleted (required) + :type username: str + :param body: Updated user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_user_with_http_info(username, body, **kwargs) # noqa: E501 @@ -836,24 +919,31 @@ def update_user_with_http_info(self, username, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user_with_http_info(username, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: name that need to be deleted (required) - :param User body: Updated user object (required) + :param username: name that need to be deleted (required) + :type username: str + :param body: Updated user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_any_type.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_any_type.py index 2954285de87c..690c71705b9c 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_any_type.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_any_type.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesAnyType. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_array.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_array.py index c6369c22a12f..f0902bdaffac 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_array.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_array.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesArray. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_boolean.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_boolean.py index 599b7c8b8843..f79d2609a1df 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_boolean.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_boolean.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesBoolean. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_class.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_class.py index be4455c683bf..ca334635175d 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_class.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_class.py @@ -118,7 +118,7 @@ def map_string(self, map_string): :param map_string: The map_string of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, str) + :type map_string: dict(str, str) """ self._map_string = map_string @@ -139,7 +139,7 @@ def map_number(self, map_number): :param map_number: The map_number of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, float) + :type map_number: dict(str, float) """ self._map_number = map_number @@ -160,7 +160,7 @@ def map_integer(self, map_integer): :param map_integer: The map_integer of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, int) + :type map_integer: dict(str, int) """ self._map_integer = map_integer @@ -181,7 +181,7 @@ def map_boolean(self, map_boolean): :param map_boolean: The map_boolean of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, bool) + :type map_boolean: dict(str, bool) """ self._map_boolean = map_boolean @@ -202,7 +202,7 @@ def map_array_integer(self, map_array_integer): :param map_array_integer: The map_array_integer of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, list[int]) + :type map_array_integer: dict(str, list[int]) """ self._map_array_integer = map_array_integer @@ -223,7 +223,7 @@ def map_array_anytype(self, map_array_anytype): :param map_array_anytype: The map_array_anytype of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, list[object]) + :type map_array_anytype: dict(str, list[object]) """ self._map_array_anytype = map_array_anytype @@ -244,7 +244,7 @@ def map_map_string(self, map_map_string): :param map_map_string: The map_map_string of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, dict(str, str)) + :type map_map_string: dict(str, dict(str, str)) """ self._map_map_string = map_map_string @@ -265,7 +265,7 @@ def map_map_anytype(self, map_map_anytype): :param map_map_anytype: The map_map_anytype of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, dict(str, object)) + :type map_map_anytype: dict(str, dict(str, object)) """ self._map_map_anytype = map_map_anytype @@ -286,7 +286,7 @@ def anytype_1(self, anytype_1): :param anytype_1: The anytype_1 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_1: object """ self._anytype_1 = anytype_1 @@ -307,7 +307,7 @@ def anytype_2(self, anytype_2): :param anytype_2: The anytype_2 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_2: object """ self._anytype_2 = anytype_2 @@ -328,7 +328,7 @@ def anytype_3(self, anytype_3): :param anytype_3: The anytype_3 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_3: object """ self._anytype_3 = anytype_3 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_integer.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_integer.py index ddbb85fdf33b..5c3ebf230d10 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_integer.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_integer.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesInteger. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_number.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_number.py index 8bbeda83ecca..0e7f34ed329f 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_number.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_number.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesNumber. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_object.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_object.py index af87595b3e41..5a8ea94b929b 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_object.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_object.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesObject. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_string.py b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_string.py index 6ab2c91feda9..8436a1e345b0 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_string.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/additional_properties_string.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesString. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/animal.py b/samples/client/petstore/python-tornado/petstore_api/models/animal.py index b338e0eb18e9..eef35ab093ab 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/animal.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/animal.py @@ -78,7 +78,7 @@ def class_name(self, class_name): :param class_name: The class_name of this Animal. # noqa: E501 - :type: str + :type class_name: str """ if self.local_vars_configuration.client_side_validation and class_name is None: # noqa: E501 raise ValueError("Invalid value for `class_name`, must not be `None`") # noqa: E501 @@ -101,7 +101,7 @@ def color(self, color): :param color: The color of this Animal. # noqa: E501 - :type: str + :type color: str """ self._color = color diff --git a/samples/client/petstore/python-tornado/petstore_api/models/api_response.py b/samples/client/petstore/python-tornado/petstore_api/models/api_response.py index 24e80d02aea4..8cb64673c354 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/api_response.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/api_response.py @@ -78,7 +78,7 @@ def code(self, code): :param code: The code of this ApiResponse. # noqa: E501 - :type: int + :type code: int """ self._code = code @@ -99,7 +99,7 @@ def type(self, type): :param type: The type of this ApiResponse. # noqa: E501 - :type: str + :type type: str """ self._type = type @@ -120,7 +120,7 @@ def message(self, message): :param message: The message of this ApiResponse. # noqa: E501 - :type: str + :type message: str """ self._message = message diff --git a/samples/client/petstore/python-tornado/petstore_api/models/array_of_array_of_number_only.py b/samples/client/petstore/python-tornado/petstore_api/models/array_of_array_of_number_only.py index 1f654452077f..41a689c534ac 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/array_of_array_of_number_only.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/array_of_array_of_number_only.py @@ -68,7 +68,7 @@ def array_array_number(self, array_array_number): :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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/array_of_number_only.py b/samples/client/petstore/python-tornado/petstore_api/models/array_of_number_only.py index 27ba1f58e31e..ddb7f7c7abe0 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/array_of_number_only.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/array_of_number_only.py @@ -68,7 +68,7 @@ def array_number(self, array_number): :param array_number: The array_number of this ArrayOfNumberOnly. # noqa: E501 - :type: list[float] + :type array_number: list[float] """ self._array_number = array_number diff --git a/samples/client/petstore/python-tornado/petstore_api/models/array_test.py b/samples/client/petstore/python-tornado/petstore_api/models/array_test.py index f34a372f6f3b..e8e5c378f98e 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/array_test.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/array_test.py @@ -78,7 +78,7 @@ def array_of_string(self, array_of_string): :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 @@ def array_array_of_integer(self, array_array_of_integer): :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 @@ def array_array_of_model(self, array_array_of_model): :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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/big_cat.py b/samples/client/petstore/python-tornado/petstore_api/models/big_cat.py index fe52c3650ac5..946981f5b7fa 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/big_cat.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/big_cat.py @@ -68,7 +68,7 @@ def kind(self, kind): :param kind: The kind of this BigCat. # noqa: E501 - :type: str + :type kind: str """ allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501 if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/big_cat_all_of.py b/samples/client/petstore/python-tornado/petstore_api/models/big_cat_all_of.py index b75500db987e..41c205d2576f 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/big_cat_all_of.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/big_cat_all_of.py @@ -68,7 +68,7 @@ def kind(self, kind): :param kind: The kind of this BigCatAllOf. # noqa: E501 - :type: str + :type kind: str """ allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501 if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/capitalization.py b/samples/client/petstore/python-tornado/petstore_api/models/capitalization.py index cef34c5f6dc3..967d324a0ab0 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/capitalization.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/capitalization.py @@ -93,7 +93,7 @@ def small_camel(self, small_camel): :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 @@ def capital_camel(self, capital_camel): :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 @@ def small_snake(self, small_snake): :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 @@ def capital_snake(self, capital_snake): :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 @@ def sca_eth_flow_points(self, sca_eth_flow_points): :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 @@ def att_name(self, att_name): 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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/cat.py b/samples/client/petstore/python-tornado/petstore_api/models/cat.py index e39c1c82508c..b3b0d868c7f0 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/cat.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/cat.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this Cat. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/client/petstore/python-tornado/petstore_api/models/cat_all_of.py b/samples/client/petstore/python-tornado/petstore_api/models/cat_all_of.py index 7e90fab93489..f573a04636c1 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/cat_all_of.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/cat_all_of.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this CatAllOf. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/client/petstore/python-tornado/petstore_api/models/category.py b/samples/client/petstore/python-tornado/petstore_api/models/category.py index b47c148953ea..11a7bf85f3ad 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/category.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/category.py @@ -72,7 +72,7 @@ def id(self, id): :param id: The id of this Category. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -93,7 +93,7 @@ def name(self, name): :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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/class_model.py b/samples/client/petstore/python-tornado/petstore_api/models/class_model.py index ef6060ffa70d..aac505ea064d 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/class_model.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/class_model.py @@ -68,7 +68,7 @@ def _class(self, _class): :param _class: The _class of this ClassModel. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/client/petstore/python-tornado/petstore_api/models/client.py b/samples/client/petstore/python-tornado/petstore_api/models/client.py index ee5dbf1c43a1..2006350b2109 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/client.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/client.py @@ -68,7 +68,7 @@ def client(self, client): :param client: The client of this Client. # noqa: E501 - :type: str + :type client: str """ self._client = client diff --git a/samples/client/petstore/python-tornado/petstore_api/models/dog.py b/samples/client/petstore/python-tornado/petstore_api/models/dog.py index eacb63eedb09..fb9024d0bb76 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/dog.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/dog.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this Dog. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/client/petstore/python-tornado/petstore_api/models/dog_all_of.py b/samples/client/petstore/python-tornado/petstore_api/models/dog_all_of.py index 48e048557085..5943ba900dd6 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/dog_all_of.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/dog_all_of.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this DogAllOf. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/client/petstore/python-tornado/petstore_api/models/enum_arrays.py b/samples/client/petstore/python-tornado/petstore_api/models/enum_arrays.py index 819ff322157d..ae2ea1d42511 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/enum_arrays.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/enum_arrays.py @@ -73,7 +73,7 @@ def just_symbol(self, just_symbol): :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 @@ def array_enum(self, array_enum): :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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/enum_test.py b/samples/client/petstore/python-tornado/petstore_api/models/enum_test.py index 464281b3ec0e..e9872c4d005a 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/enum_test.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/enum_test.py @@ -87,7 +87,7 @@ def enum_string(self, enum_string): :param enum_string: The enum_string of this EnumTest. # noqa: E501 - :type: str + :type enum_string: str """ allowed_values = ["UPPER", "lower", ""] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_string not in allowed_values: # noqa: E501 @@ -114,7 +114,7 @@ def enum_string_required(self, enum_string_required): :param enum_string_required: The enum_string_required of this EnumTest. # noqa: E501 - :type: str + :type enum_string_required: str """ if self.local_vars_configuration.client_side_validation and enum_string_required is None: # noqa: E501 raise ValueError("Invalid value for `enum_string_required`, must not be `None`") # noqa: E501 @@ -143,7 +143,7 @@ def enum_integer(self, enum_integer): :param enum_integer: The enum_integer of this EnumTest. # noqa: E501 - :type: int + :type enum_integer: int """ allowed_values = [1, -1] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_integer not in allowed_values: # noqa: E501 @@ -170,7 +170,7 @@ def enum_number(self, enum_number): :param enum_number: The enum_number of this EnumTest. # noqa: E501 - :type: float + :type enum_number: float """ allowed_values = [1.1, -1.2] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_number not in allowed_values: # noqa: E501 @@ -197,7 +197,7 @@ def outer_enum(self, outer_enum): :param outer_enum: The outer_enum of this EnumTest. # noqa: E501 - :type: OuterEnum + :type outer_enum: OuterEnum """ self._outer_enum = outer_enum diff --git a/samples/client/petstore/python-tornado/petstore_api/models/file.py b/samples/client/petstore/python-tornado/petstore_api/models/file.py index 282df2957e67..4fb5c31762e8 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/file.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/file.py @@ -70,7 +70,7 @@ def source_uri(self, source_uri): 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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/file_schema_test_class.py b/samples/client/petstore/python-tornado/petstore_api/models/file_schema_test_class.py index de7f865b47e2..2f2d44a7b33d 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/file_schema_test_class.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/file_schema_test_class.py @@ -73,7 +73,7 @@ def file(self, file): :param file: The file of this FileSchemaTestClass. # noqa: E501 - :type: File + :type file: File """ self._file = file @@ -94,7 +94,7 @@ def files(self, files): :param files: The files of this FileSchemaTestClass. # noqa: E501 - :type: list[File] + :type files: list[File] """ self._files = files diff --git a/samples/client/petstore/python-tornado/petstore_api/models/format_test.py b/samples/client/petstore/python-tornado/petstore_api/models/format_test.py index 6396c442f624..c96f8132fa61 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/format_test.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/format_test.py @@ -129,7 +129,7 @@ def integer(self, integer): :param integer: The integer of this FormatTest. # noqa: E501 - :type: int + :type integer: int """ if (self.local_vars_configuration.client_side_validation and integer is not None and integer > 100): # noqa: E501 @@ -156,7 +156,7 @@ def int32(self, int32): :param int32: The int32 of this FormatTest. # noqa: E501 - :type: int + :type int32: int """ if (self.local_vars_configuration.client_side_validation and int32 is not None and int32 > 200): # noqa: E501 @@ -183,7 +183,7 @@ def int64(self, int64): :param int64: The int64 of this FormatTest. # noqa: E501 - :type: int + :type int64: int """ self._int64 = int64 @@ -204,7 +204,7 @@ def number(self, number): :param number: The number of this FormatTest. # noqa: E501 - :type: float + :type number: float """ if self.local_vars_configuration.client_side_validation and number is None: # noqa: E501 raise ValueError("Invalid value for `number`, must not be `None`") # noqa: E501 @@ -233,7 +233,7 @@ def float(self, float): :param float: The float of this FormatTest. # noqa: E501 - :type: float + :type float: float """ if (self.local_vars_configuration.client_side_validation and float is not None and float > 987.6): # noqa: E501 @@ -260,7 +260,7 @@ def double(self, double): :param double: The double of this FormatTest. # noqa: E501 - :type: float + :type double: float """ if (self.local_vars_configuration.client_side_validation and double is not None and double > 123.4): # noqa: E501 @@ -287,7 +287,7 @@ def string(self, string): :param string: The string of this FormatTest. # noqa: E501 - :type: str + :type string: str """ if (self.local_vars_configuration.client_side_validation and string is not None and not re.search(r'[a-z]', string, flags=re.IGNORECASE)): # noqa: E501 @@ -311,7 +311,7 @@ def byte(self, byte): :param byte: The byte of this FormatTest. # noqa: E501 - :type: str + :type byte: str """ if self.local_vars_configuration.client_side_validation and byte is None: # noqa: E501 raise ValueError("Invalid value for `byte`, must not be `None`") # noqa: E501 @@ -337,7 +337,7 @@ def binary(self, binary): :param binary: The binary of this FormatTest. # noqa: E501 - :type: file + :type binary: file """ self._binary = binary @@ -358,7 +358,7 @@ def date(self, date): :param date: The date of this FormatTest. # noqa: E501 - :type: date + :type date: date """ if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501 raise ValueError("Invalid value for `date`, must not be `None`") # noqa: E501 @@ -381,7 +381,7 @@ def date_time(self, date_time): :param date_time: The date_time of this FormatTest. # noqa: E501 - :type: datetime + :type date_time: datetime """ self._date_time = date_time @@ -402,7 +402,7 @@ def uuid(self, uuid): :param uuid: The uuid of this FormatTest. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -423,7 +423,7 @@ def password(self, password): :param password: The password of this FormatTest. # noqa: E501 - :type: str + :type password: str """ if self.local_vars_configuration.client_side_validation and password is None: # noqa: E501 raise ValueError("Invalid value for `password`, must not be `None`") # noqa: E501 @@ -452,7 +452,7 @@ def big_decimal(self, big_decimal): :param big_decimal: The big_decimal of this FormatTest. # noqa: E501 - :type: BigDecimal + :type big_decimal: BigDecimal """ self._big_decimal = big_decimal diff --git a/samples/client/petstore/python-tornado/petstore_api/models/has_only_read_only.py b/samples/client/petstore/python-tornado/petstore_api/models/has_only_read_only.py index 5fc2f8a9ebdd..fa496519ecb2 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/has_only_read_only.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/has_only_read_only.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def foo(self, foo): :param foo: The foo of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type foo: str """ self._foo = foo diff --git a/samples/client/petstore/python-tornado/petstore_api/models/list.py b/samples/client/petstore/python-tornado/petstore_api/models/list.py index d58d13e90fbc..e21a220f71cd 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/list.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/list.py @@ -68,7 +68,7 @@ def _123_list(self, _123_list): :param _123_list: The _123_list of this List. # noqa: E501 - :type: str + :type _123_list: str """ self.__123_list = _123_list diff --git a/samples/client/petstore/python-tornado/petstore_api/models/map_test.py b/samples/client/petstore/python-tornado/petstore_api/models/map_test.py index f0cfba5073b0..8afc875ce517 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/map_test.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/map_test.py @@ -83,7 +83,7 @@ def map_map_of_string(self, map_map_of_string): :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 @@ def map_of_enum_string(self, map_of_enum_string): :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 @@ def direct_map(self, direct_map): :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 @@ def indirect_map(self, indirect_map): :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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/mixed_properties_and_additional_properties_class.py b/samples/client/petstore/python-tornado/petstore_api/models/mixed_properties_and_additional_properties_class.py index 5da34f8830e8..8aecbf0f558a 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/mixed_properties_and_additional_properties_class.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/mixed_properties_and_additional_properties_class.py @@ -78,7 +78,7 @@ def uuid(self, uuid): :param uuid: The uuid of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -99,7 +99,7 @@ def date_time(self, date_time): :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 @@ def map(self, map): :param map: The map of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: dict(str, Animal) + :type map: dict(str, Animal) """ self._map = map diff --git a/samples/client/petstore/python-tornado/petstore_api/models/model200_response.py b/samples/client/petstore/python-tornado/petstore_api/models/model200_response.py index 841ce1f18f3d..3f4c4e2bd2a7 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/model200_response.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/model200_response.py @@ -73,7 +73,7 @@ def name(self, name): :param name: The name of this Model200Response. # noqa: E501 - :type: int + :type name: int """ self._name = name @@ -94,7 +94,7 @@ def _class(self, _class): :param _class: The _class of this Model200Response. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/client/petstore/python-tornado/petstore_api/models/model_return.py b/samples/client/petstore/python-tornado/petstore_api/models/model_return.py index fdd8d72314ad..1009c50ef08e 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/model_return.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/model_return.py @@ -68,7 +68,7 @@ def _return(self, _return): :param _return: The _return of this ModelReturn. # noqa: E501 - :type: int + :type _return: int """ self.__return = _return diff --git a/samples/client/petstore/python-tornado/petstore_api/models/name.py b/samples/client/petstore/python-tornado/petstore_api/models/name.py index bb2c1fbd73cc..6ee8261e7821 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/name.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/name.py @@ -82,7 +82,7 @@ def name(self, name): :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 @@ def snake_case(self, snake_case): :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 @@ def _property(self, _property): :param _property: The _property of this Name. # noqa: E501 - :type: str + :type _property: str """ self.__property = _property @@ -147,7 +147,7 @@ def _123_number(self, _123_number): :param _123_number: The _123_number of this Name. # noqa: E501 - :type: int + :type _123_number: int """ self.__123_number = _123_number diff --git a/samples/client/petstore/python-tornado/petstore_api/models/number_only.py b/samples/client/petstore/python-tornado/petstore_api/models/number_only.py index 99b2424852fb..90f09d8b7d56 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/number_only.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/number_only.py @@ -68,7 +68,7 @@ def just_number(self, just_number): :param just_number: The just_number of this NumberOnly. # noqa: E501 - :type: float + :type just_number: float """ self._just_number = just_number diff --git a/samples/client/petstore/python-tornado/petstore_api/models/order.py b/samples/client/petstore/python-tornado/petstore_api/models/order.py index 8c863cce8fe5..8f298aa3d9c2 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/order.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/order.py @@ -93,7 +93,7 @@ def id(self, id): :param id: The id of this Order. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -114,7 +114,7 @@ def pet_id(self, pet_id): :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 @@ def quantity(self, quantity): :param quantity: The quantity of this Order. # noqa: E501 - :type: int + :type quantity: int """ self._quantity = quantity @@ -156,7 +156,7 @@ def ship_date(self, ship_date): :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 @@ def status(self, status): 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 @@ def complete(self, complete): :param complete: The complete of this Order. # noqa: E501 - :type: bool + :type complete: bool """ self._complete = complete diff --git a/samples/client/petstore/python-tornado/petstore_api/models/outer_composite.py b/samples/client/petstore/python-tornado/petstore_api/models/outer_composite.py index c11859114a57..85fe36c7ef07 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/outer_composite.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/outer_composite.py @@ -78,7 +78,7 @@ def my_number(self, my_number): :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 @@ def my_string(self, my_string): :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 @@ def my_boolean(self, my_boolean): :param my_boolean: The my_boolean of this OuterComposite. # noqa: E501 - :type: bool + :type my_boolean: bool """ self._my_boolean = my_boolean diff --git a/samples/client/petstore/python-tornado/petstore_api/models/pet.py b/samples/client/petstore/python-tornado/petstore_api/models/pet.py index edbf73f53127..b948a6436db1 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/pet.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/pet.py @@ -91,7 +91,7 @@ def id(self, id): :param id: The id of this Pet. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -112,7 +112,7 @@ def category(self, category): :param category: The category of this Pet. # noqa: E501 - :type: Category + :type category: Category """ self._category = category @@ -133,7 +133,7 @@ def name(self, name): :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 @@ def photo_urls(self, photo_urls): :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 @@ def tags(self, tags): :param tags: The tags of this Pet. # noqa: E501 - :type: list[Tag] + :type tags: list[Tag] """ self._tags = tags @@ -202,7 +202,7 @@ def status(self, status): 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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/read_only_first.py b/samples/client/petstore/python-tornado/petstore_api/models/read_only_first.py index a84679e98dee..3a305087dc26 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/read_only_first.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/read_only_first.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this ReadOnlyFirst. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def baz(self, baz): :param baz: The baz of this ReadOnlyFirst. # noqa: E501 - :type: str + :type baz: str """ self._baz = baz diff --git a/samples/client/petstore/python-tornado/petstore_api/models/special_model_name.py b/samples/client/petstore/python-tornado/petstore_api/models/special_model_name.py index 396e75bcee5c..d2535eb65aca 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/special_model_name.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/special_model_name.py @@ -68,7 +68,7 @@ def special_property_name(self, special_property_name): :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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/tag.py b/samples/client/petstore/python-tornado/petstore_api/models/tag.py index d6137fdd47f0..7492d30d9eb6 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/tag.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/tag.py @@ -73,7 +73,7 @@ def id(self, id): :param id: The id of this Tag. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -94,7 +94,7 @@ def name(self, name): :param name: The name of this Tag. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python-tornado/petstore_api/models/type_holder_default.py b/samples/client/petstore/python-tornado/petstore_api/models/type_holder_default.py index 8163ea77aa73..fbef6b4b1574 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/type_holder_default.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/type_holder_default.py @@ -83,7 +83,7 @@ def string_item(self, string_item): :param string_item: The string_item of this TypeHolderDefault. # noqa: E501 - :type: str + :type string_item: str """ if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501 raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501 @@ -106,7 +106,7 @@ def number_item(self, number_item): :param number_item: The number_item of this TypeHolderDefault. # noqa: E501 - :type: float + :type number_item: float """ if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501 raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501 @@ -129,7 +129,7 @@ def integer_item(self, integer_item): :param integer_item: The integer_item of this TypeHolderDefault. # noqa: E501 - :type: int + :type integer_item: int """ if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501 raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501 @@ -152,7 +152,7 @@ def bool_item(self, bool_item): :param bool_item: The bool_item of this TypeHolderDefault. # noqa: E501 - :type: bool + :type bool_item: bool """ if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501 raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501 @@ -175,7 +175,7 @@ def array_item(self, array_item): :param array_item: The array_item of this TypeHolderDefault. # noqa: E501 - :type: list[int] + :type array_item: list[int] """ if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501 raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/type_holder_example.py b/samples/client/petstore/python-tornado/petstore_api/models/type_holder_example.py index 34481fd21e31..b7320bed0ca7 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/type_holder_example.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/type_holder_example.py @@ -87,7 +87,7 @@ def string_item(self, string_item): :param string_item: The string_item of this TypeHolderExample. # noqa: E501 - :type: str + :type string_item: str """ if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501 raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501 @@ -110,7 +110,7 @@ def number_item(self, number_item): :param number_item: The number_item of this TypeHolderExample. # noqa: E501 - :type: float + :type number_item: float """ if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501 raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501 @@ -133,7 +133,7 @@ def float_item(self, float_item): :param float_item: The float_item of this TypeHolderExample. # noqa: E501 - :type: float + :type float_item: float """ if self.local_vars_configuration.client_side_validation and float_item is None: # noqa: E501 raise ValueError("Invalid value for `float_item`, must not be `None`") # noqa: E501 @@ -156,7 +156,7 @@ def integer_item(self, integer_item): :param integer_item: The integer_item of this TypeHolderExample. # noqa: E501 - :type: int + :type integer_item: int """ if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501 raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501 @@ -179,7 +179,7 @@ def bool_item(self, bool_item): :param bool_item: The bool_item of this TypeHolderExample. # noqa: E501 - :type: bool + :type bool_item: bool """ if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501 raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501 @@ -202,7 +202,7 @@ def array_item(self, array_item): :param array_item: The array_item of this TypeHolderExample. # noqa: E501 - :type: list[int] + :type array_item: list[int] """ if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501 raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/user.py b/samples/client/petstore/python-tornado/petstore_api/models/user.py index de88bda4cde7..0e25f9f17104 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/user.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/user.py @@ -103,7 +103,7 @@ def id(self, id): :param id: The id of this User. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -124,7 +124,7 @@ def username(self, username): :param username: The username of this User. # noqa: E501 - :type: str + :type username: str """ self._username = username @@ -145,7 +145,7 @@ def first_name(self, first_name): :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 @@ def last_name(self, last_name): :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 @@ def email(self, email): :param email: The email of this User. # noqa: E501 - :type: str + :type email: str """ self._email = email @@ -208,7 +208,7 @@ def password(self, password): :param password: The password of this User. # noqa: E501 - :type: str + :type password: str """ self._password = password @@ -229,7 +229,7 @@ def phone(self, phone): :param phone: The phone of this User. # noqa: E501 - :type: str + :type phone: str """ self._phone = phone @@ -252,7 +252,7 @@ def user_status(self, user_status): 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 diff --git a/samples/client/petstore/python-tornado/petstore_api/models/xml_item.py b/samples/client/petstore/python-tornado/petstore_api/models/xml_item.py index 52ecc9aa5225..afb75967cb0b 100644 --- a/samples/client/petstore/python-tornado/petstore_api/models/xml_item.py +++ b/samples/client/petstore/python-tornado/petstore_api/models/xml_item.py @@ -208,7 +208,7 @@ def attribute_string(self, attribute_string): :param attribute_string: The attribute_string of this XmlItem. # noqa: E501 - :type: str + :type attribute_string: str """ self._attribute_string = attribute_string @@ -229,7 +229,7 @@ def attribute_number(self, attribute_number): :param attribute_number: The attribute_number of this XmlItem. # noqa: E501 - :type: float + :type attribute_number: float """ self._attribute_number = attribute_number @@ -250,7 +250,7 @@ def attribute_integer(self, attribute_integer): :param attribute_integer: The attribute_integer of this XmlItem. # noqa: E501 - :type: int + :type attribute_integer: int """ self._attribute_integer = attribute_integer @@ -271,7 +271,7 @@ def attribute_boolean(self, attribute_boolean): :param attribute_boolean: The attribute_boolean of this XmlItem. # noqa: E501 - :type: bool + :type attribute_boolean: bool """ self._attribute_boolean = attribute_boolean @@ -292,7 +292,7 @@ def wrapped_array(self, wrapped_array): :param wrapped_array: The wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type wrapped_array: list[int] """ self._wrapped_array = wrapped_array @@ -313,7 +313,7 @@ def name_string(self, name_string): :param name_string: The name_string of this XmlItem. # noqa: E501 - :type: str + :type name_string: str """ self._name_string = name_string @@ -334,7 +334,7 @@ def name_number(self, name_number): :param name_number: The name_number of this XmlItem. # noqa: E501 - :type: float + :type name_number: float """ self._name_number = name_number @@ -355,7 +355,7 @@ def name_integer(self, name_integer): :param name_integer: The name_integer of this XmlItem. # noqa: E501 - :type: int + :type name_integer: int """ self._name_integer = name_integer @@ -376,7 +376,7 @@ def name_boolean(self, name_boolean): :param name_boolean: The name_boolean of this XmlItem. # noqa: E501 - :type: bool + :type name_boolean: bool """ self._name_boolean = name_boolean @@ -397,7 +397,7 @@ def name_array(self, name_array): :param name_array: The name_array of this XmlItem. # noqa: E501 - :type: list[int] + :type name_array: list[int] """ self._name_array = name_array @@ -418,7 +418,7 @@ def name_wrapped_array(self, name_wrapped_array): :param name_wrapped_array: The name_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type name_wrapped_array: list[int] """ self._name_wrapped_array = name_wrapped_array @@ -439,7 +439,7 @@ def prefix_string(self, prefix_string): :param prefix_string: The prefix_string of this XmlItem. # noqa: E501 - :type: str + :type prefix_string: str """ self._prefix_string = prefix_string @@ -460,7 +460,7 @@ def prefix_number(self, prefix_number): :param prefix_number: The prefix_number of this XmlItem. # noqa: E501 - :type: float + :type prefix_number: float """ self._prefix_number = prefix_number @@ -481,7 +481,7 @@ def prefix_integer(self, prefix_integer): :param prefix_integer: The prefix_integer of this XmlItem. # noqa: E501 - :type: int + :type prefix_integer: int """ self._prefix_integer = prefix_integer @@ -502,7 +502,7 @@ def prefix_boolean(self, prefix_boolean): :param prefix_boolean: The prefix_boolean of this XmlItem. # noqa: E501 - :type: bool + :type prefix_boolean: bool """ self._prefix_boolean = prefix_boolean @@ -523,7 +523,7 @@ def prefix_array(self, prefix_array): :param prefix_array: The prefix_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_array: list[int] """ self._prefix_array = prefix_array @@ -544,7 +544,7 @@ def prefix_wrapped_array(self, prefix_wrapped_array): :param prefix_wrapped_array: The prefix_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_wrapped_array: list[int] """ self._prefix_wrapped_array = prefix_wrapped_array @@ -565,7 +565,7 @@ def namespace_string(self, namespace_string): :param namespace_string: The namespace_string of this XmlItem. # noqa: E501 - :type: str + :type namespace_string: str """ self._namespace_string = namespace_string @@ -586,7 +586,7 @@ def namespace_number(self, namespace_number): :param namespace_number: The namespace_number of this XmlItem. # noqa: E501 - :type: float + :type namespace_number: float """ self._namespace_number = namespace_number @@ -607,7 +607,7 @@ def namespace_integer(self, namespace_integer): :param namespace_integer: The namespace_integer of this XmlItem. # noqa: E501 - :type: int + :type namespace_integer: int """ self._namespace_integer = namespace_integer @@ -628,7 +628,7 @@ def namespace_boolean(self, namespace_boolean): :param namespace_boolean: The namespace_boolean of this XmlItem. # noqa: E501 - :type: bool + :type namespace_boolean: bool """ self._namespace_boolean = namespace_boolean @@ -649,7 +649,7 @@ def namespace_array(self, namespace_array): :param namespace_array: The namespace_array of this XmlItem. # noqa: E501 - :type: list[int] + :type namespace_array: list[int] """ self._namespace_array = namespace_array @@ -670,7 +670,7 @@ def namespace_wrapped_array(self, namespace_wrapped_array): :param namespace_wrapped_array: The namespace_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type namespace_wrapped_array: list[int] """ self._namespace_wrapped_array = namespace_wrapped_array @@ -691,7 +691,7 @@ def prefix_ns_string(self, prefix_ns_string): :param prefix_ns_string: The prefix_ns_string of this XmlItem. # noqa: E501 - :type: str + :type prefix_ns_string: str """ self._prefix_ns_string = prefix_ns_string @@ -712,7 +712,7 @@ def prefix_ns_number(self, prefix_ns_number): :param prefix_ns_number: The prefix_ns_number of this XmlItem. # noqa: E501 - :type: float + :type prefix_ns_number: float """ self._prefix_ns_number = prefix_ns_number @@ -733,7 +733,7 @@ def prefix_ns_integer(self, prefix_ns_integer): :param prefix_ns_integer: The prefix_ns_integer of this XmlItem. # noqa: E501 - :type: int + :type prefix_ns_integer: int """ self._prefix_ns_integer = prefix_ns_integer @@ -754,7 +754,7 @@ def prefix_ns_boolean(self, prefix_ns_boolean): :param prefix_ns_boolean: The prefix_ns_boolean of this XmlItem. # noqa: E501 - :type: bool + :type prefix_ns_boolean: bool """ self._prefix_ns_boolean = prefix_ns_boolean @@ -775,7 +775,7 @@ def prefix_ns_array(self, prefix_ns_array): :param prefix_ns_array: The prefix_ns_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_ns_array: list[int] """ self._prefix_ns_array = prefix_ns_array @@ -796,7 +796,7 @@ def prefix_ns_wrapped_array(self, prefix_ns_wrapped_array): :param prefix_ns_wrapped_array: The prefix_ns_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_ns_wrapped_array: list[int] """ self._prefix_ns_wrapped_array = prefix_ns_wrapped_array diff --git a/samples/client/petstore/python/petstore_api/api/another_fake_api.py b/samples/client/petstore/python/petstore_api/api/another_fake_api.py index 77c4c003fe4e..4d69b287ca8b 100644 --- a/samples/client/petstore/python/petstore_api/api/another_fake_api.py +++ b/samples/client/petstore/python/petstore_api/api/another_fake_api.py @@ -42,21 +42,26 @@ def call_123_test_special_tags(self, body, **kwargs): # noqa: E501 To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.call_123_test_special_tags_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def call_123_test_special_tags_with_http_info(self, body, **kwargs): # noqa: E5 To test special tags and operation ID starting with number # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.call_123_test_special_tags_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python/petstore_api/api/fake_api.py b/samples/client/petstore/python/petstore_api/api/fake_api.py index 667c50612ce6..e1d9ffebebfe 100644 --- a/samples/client/petstore/python/petstore_api/api/fake_api.py +++ b/samples/client/petstore/python/petstore_api/api/fake_api.py @@ -42,21 +42,26 @@ def create_xml_item(self, xml_item, **kwargs): # noqa: E501 this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item(xml_item, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param XmlItem xml_item: XmlItem Body (required) + :param xml_item: XmlItem Body (required) + :type xml_item: XmlItem + :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_xml_item_with_http_info(xml_item, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def create_xml_item_with_http_info(self, xml_item, **kwargs): # noqa: E501 this route creates an XmlItem # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_xml_item_with_http_info(xml_item, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param XmlItem xml_item: XmlItem Body (required) + :param xml_item: XmlItem Body (required) + :type xml_item: XmlItem + :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() @@ -156,21 +167,26 @@ def fake_outer_boolean_serialize(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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: bool + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: bool """ kwargs['_return_http_data_only'] = True return self.fake_outer_boolean_serialize_with_http_info(**kwargs) # noqa: E501 @@ -181,23 +197,29 @@ def fake_outer_boolean_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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(bool, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(bool, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -266,21 +288,26 @@ def fake_outer_composite_serialize(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite body: Input composite as post body + :param body: Input composite as post body + :type body: OuterComposite + :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: OuterComposite + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: OuterComposite """ kwargs['_return_http_data_only'] = True return self.fake_outer_composite_serialize_with_http_info(**kwargs) # noqa: E501 @@ -291,23 +318,29 @@ def fake_outer_composite_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite body: Input composite as post body + :param body: Input composite as post body + :type body: OuterComposite + :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(OuterComposite, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(OuterComposite, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -376,21 +409,26 @@ def fake_outer_number_serialize(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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: float + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: float """ kwargs['_return_http_data_only'] = True return self.fake_outer_number_serialize_with_http_info(**kwargs) # noqa: E501 @@ -401,23 +439,29 @@ def fake_outer_number_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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(float, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(float, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -486,21 +530,26 @@ def fake_outer_string_serialize(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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.fake_outer_string_serialize_with_http_info(**kwargs) # noqa: E501 @@ -511,23 +560,29 @@ def fake_outer_string_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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() @@ -596,21 +651,26 @@ def test_body_with_file_schema(self, body, **kwargs): # noqa: E501 For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass body: (required) + :param body: (required) + :type body: FileSchemaTestClass + :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.test_body_with_file_schema_with_http_info(body, **kwargs) # noqa: E501 @@ -621,23 +681,29 @@ def test_body_with_file_schema_with_http_info(self, body, **kwargs): # noqa: E5 For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass body: (required) + :param body: (required) + :type body: FileSchemaTestClass + :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() @@ -709,22 +775,28 @@ def test_body_with_query_params(self, query, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params(query, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User body: (required) + :param query: (required) + :type query: str + :param body: (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.test_body_with_query_params_with_http_info(query, body, **kwargs) # noqa: E501 @@ -734,24 +806,31 @@ def test_body_with_query_params_with_http_info(self, query, body, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params_with_http_info(query, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User body: (required) + :param query: (required) + :type query: str + :param body: (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -831,21 +910,26 @@ def test_client_model(self, body, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.test_client_model_with_http_info(body, **kwargs) # noqa: E501 @@ -856,23 +940,29 @@ def test_client_model_with_http_info(self, body, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -949,34 +1039,52 @@ def test_endpoint_parameters(self, number, double, pattern_without_delimiter, by Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, **kwargs) # noqa: E501 @@ -987,36 +1095,55 @@ def test_endpoint_parameters_with_http_info(self, number, double, pattern_withou Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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() @@ -1168,28 +1295,40 @@ def test_enum_parameters(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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.test_enum_parameters_with_http_info(**kwargs) # noqa: E501 @@ -1200,30 +1339,43 @@ def test_enum_parameters_with_http_info(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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() @@ -1316,26 +1468,36 @@ def test_group_parameters(self, required_string_group, required_boolean_group, r Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: 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.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, **kwargs) # noqa: E501 @@ -1346,28 +1508,39 @@ def test_group_parameters_with_http_info(self, required_string_group, required_b Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -1458,21 +1631,26 @@ def test_inline_additional_properties(self, param, **kwargs): # 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_inline_additional_properties(param, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) param: request body (required) + :param param: request body (required) + :type param: dict(str, 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.test_inline_additional_properties_with_http_info(param, **kwargs) # noqa: E501 @@ -1482,23 +1660,29 @@ def test_inline_additional_properties_with_http_info(self, param, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties_with_http_info(param, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) param: request body (required) + :param param: request body (required) + :type param: dict(str, 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() @@ -1570,22 +1754,28 @@ def test_json_form_data(self, param, param2, **kwargs): # 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_json_form_data(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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.test_json_form_data_with_http_info(param, param2, **kwargs) # noqa: E501 @@ -1595,24 +1785,31 @@ def test_json_form_data_with_http_info(self, param, param2, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_json_form_data_with_http_info(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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() @@ -1692,25 +1889,34 @@ def test_query_parameter_collection_format(self, pipe, ioutil, http, url, contex To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: 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.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, **kwargs) # noqa: E501 @@ -1721,27 +1927,37 @@ def test_query_parameter_collection_format_with_http_info(self, pipe, ioutil, ht To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py b/samples/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py index 2bb189bd01b9..d963591a49a8 100644 --- a/samples/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py +++ b/samples/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py @@ -42,21 +42,26 @@ def test_classname(self, body, **kwargs): # noqa: E501 To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Client + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Client """ kwargs['_return_http_data_only'] = True return self.test_classname_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def test_classname_with_http_info(self, body, **kwargs): # noqa: E501 To test class name in snake case # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_classname_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Client body: client model (required) + :param body: client model (required) + :type body: Client + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Client, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Client, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python/petstore_api/api/pet_api.py b/samples/client/petstore/python/petstore_api/api/pet_api.py index 5a297a57647b..7002fe32740f 100644 --- a/samples/client/petstore/python/petstore_api/api/pet_api.py +++ b/samples/client/petstore/python/petstore_api/api/pet_api.py @@ -41,21 +41,26 @@ def add_pet(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.add_pet_with_http_info(body, **kwargs) # noqa: E501 @@ -65,23 +70,29 @@ def add_pet_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.add_pet_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -153,22 +164,28 @@ def delete_pet(self, pet_id, **kwargs): # 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_pet(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: Pet id to delete (required) - :param str api_key: + :param pet_id: Pet id to delete (required) + :type pet_id: int + :param api_key: + :type api_key: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.delete_pet_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -178,24 +195,31 @@ def delete_pet_with_http_info(self, pet_id, **kwargs): # 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_pet_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: Pet id to delete (required) - :param str api_key: + :param pet_id: Pet id to delete (required) + :type pet_id: int + :param api_key: + :type api_key: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -267,21 +291,26 @@ def find_pets_by_status(self, status, **kwargs): # noqa: E501 Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status(status, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] status: Status values that need to be considered for filter (required) + :param status: Status values that need to be considered for filter (required) + :type status: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: list[Pet] + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: list[Pet] """ kwargs['_return_http_data_only'] = True return self.find_pets_by_status_with_http_info(status, **kwargs) # noqa: E501 @@ -292,23 +321,29 @@ def find_pets_by_status_with_http_info(self, status, **kwargs): # noqa: E501 Multiple status values can be provided with comma separated strings # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_status_with_http_info(status, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] status: Status values that need to be considered for filter (required) + :param status: Status values that need to be considered for filter (required) + :type status: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -382,21 +417,26 @@ def find_pets_by_tags(self, tags, **kwargs): # noqa: E501 Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags(tags, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] tags: Tags to filter by (required) + :param tags: Tags to filter by (required) + :type tags: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: list[Pet] + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: list[Pet] """ kwargs['_return_http_data_only'] = True return self.find_pets_by_tags_with_http_info(tags, **kwargs) # noqa: E501 @@ -407,23 +447,29 @@ def find_pets_by_tags_with_http_info(self, tags, **kwargs): # noqa: E501 Multiple tags can be provided with comma separated strings. Use tag1, tag2, tag3 for testing. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.find_pets_by_tags_with_http_info(tags, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] tags: Tags to filter by (required) + :param tags: Tags to filter by (required) + :type tags: list[str] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(list[Pet], status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -497,21 +543,26 @@ def get_pet_by_id(self, pet_id, **kwargs): # noqa: E501 Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to return (required) + :param pet_id: ID of pet to return (required) + :type pet_id: int + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Pet + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Pet """ kwargs['_return_http_data_only'] = True return self.get_pet_by_id_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -522,23 +573,29 @@ def get_pet_by_id_with_http_info(self, pet_id, **kwargs): # noqa: E501 Returns a single pet # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_pet_by_id_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to return (required) + :param pet_id: ID of pet to return (required) + :type pet_id: int + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Pet, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Pet, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -610,21 +667,26 @@ def update_pet(self, body, **kwargs): # 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_pet(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_pet_with_http_info(body, **kwargs) # noqa: E501 @@ -634,23 +696,29 @@ def update_pet_with_http_info(self, body, **kwargs): # 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_pet_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Pet body: Pet object that needs to be added to the store (required) + :param body: Pet object that needs to be added to the store (required) + :type body: Pet + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -722,23 +790,30 @@ def update_pet_with_form(self, pet_id, **kwargs): # 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_pet_with_form(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet that needs to be updated (required) - :param str name: Updated name of the pet - :param str status: Updated status of the pet + :param pet_id: ID of pet that needs to be updated (required) + :type pet_id: int + :param name: Updated name of the pet + :type name: str + :param status: Updated status of the pet + :type status: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_pet_with_form_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -748,25 +823,33 @@ def update_pet_with_form_with_http_info(self, pet_id, **kwargs): # 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_pet_with_form_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet that needs to be updated (required) - :param str name: Updated name of the pet - :param str status: Updated status of the pet + :param pet_id: ID of pet that needs to be updated (required) + :type pet_id: int + :param name: Updated name of the pet + :type name: str + :param status: Updated status of the pet + :type status: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -844,23 +927,30 @@ def upload_file(self, pet_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param str additional_metadata: Additional data to pass to server - :param file file: file to upload + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param file: file to upload + :type file: file + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiResponse """ kwargs['_return_http_data_only'] = True return self.upload_file_with_http_info(pet_id, **kwargs) # noqa: E501 @@ -870,25 +960,33 @@ def upload_file_with_http_info(self, pet_id, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file_with_http_info(pet_id, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param str additional_metadata: Additional data to pass to server - :param file file: file to upload + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param file: file to upload + :type file: file + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(ApiResponse, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -970,23 +1068,30 @@ def upload_file_with_required_file(self, pet_id, required_file, **kwargs): # no This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.upload_file_with_required_file(pet_id, required_file, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int pet_id: ID of pet to update (required) - :param file required_file: file to upload (required) - :param str additional_metadata: Additional data to pass to server + :param pet_id: ID of pet to update (required) + :type pet_id: int + :param required_file: file to upload (required) + :type required_file: file + :param additional_metadata: Additional data to pass to server + :type additional_metadata: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: ApiResponse + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: ApiResponse """ kwargs['_return_http_data_only'] = True return self.upload_file_with_required_file_with_http_info(pet_id, required_file, **kwargs) # noqa: E501 @@ -996,25 +1101,33 @@ def upload_file_with_required_file_with_http_info(self, pet_id, required_file, * 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() diff --git a/samples/client/petstore/python/petstore_api/api/store_api.py b/samples/client/petstore/python/petstore_api/api/store_api.py index f693f755b745..0ede23f05ba2 100644 --- a/samples/client/petstore/python/petstore_api/api/store_api.py +++ b/samples/client/petstore/python/petstore_api/api/store_api.py @@ -42,21 +42,26 @@ def delete_order(self, order_id, **kwargs): # noqa: E501 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 @@ def delete_order_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def get_inventory(self, **kwargs): # noqa: E501 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 @@ def get_inventory_with_http_info(self, **kwargs): # noqa: E501 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 @@ def get_order_by_id(self, order_id, **kwargs): # noqa: E501 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 @@ def get_order_by_id_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def place_order(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Order body: order placed for purchasing the pet (required) + :param body: order placed for purchasing the pet (required) + :type body: Order + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: Order + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: Order """ kwargs['_return_http_data_only'] = True return self.place_order_with_http_info(body, **kwargs) # noqa: E501 @@ -398,23 +434,29 @@ def place_order_with_http_info(self, body, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.place_order_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param Order body: order placed for purchasing the pet (required) + :param body: order placed for purchasing the pet (required) + :type body: Order + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(Order, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(Order, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() diff --git a/samples/client/petstore/python/petstore_api/api/user_api.py b/samples/client/petstore/python/petstore_api/api/user_api.py index 9462f00716a3..a912483b023b 100644 --- a/samples/client/petstore/python/petstore_api/api/user_api.py +++ b/samples/client/petstore/python/petstore_api/api/user_api.py @@ -42,21 +42,26 @@ def create_user(self, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param User body: Created user object (required) + :param body: Created user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_user_with_http_info(body, **kwargs) # noqa: E501 @@ -67,23 +72,29 @@ def create_user_with_http_info(self, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_user_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param User body: Created user object (required) + :param body: Created user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -151,21 +162,26 @@ def create_users_with_array_input(self, body, **kwargs): # 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_users_with_array_input(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_users_with_array_input_with_http_info(body, **kwargs) # noqa: E501 @@ -175,23 +191,29 @@ def create_users_with_array_input_with_http_info(self, body, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_array_input_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -259,21 +281,26 @@ def create_users_with_list_input(self, body, **kwargs): # 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_users_with_list_input(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.create_users_with_list_input_with_http_info(body, **kwargs) # noqa: E501 @@ -283,23 +310,29 @@ def create_users_with_list_input_with_http_info(self, body, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.create_users_with_list_input_with_http_info(body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[User] body: List of user object (required) + :param body: List of user object (required) + :type body: list[User] + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -368,21 +401,26 @@ def delete_user(self, username, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be deleted (required) + :param username: The name that needs to be deleted (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.delete_user_with_http_info(username, **kwargs) # noqa: E501 @@ -393,23 +431,29 @@ def delete_user_with_http_info(self, username, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_user_with_http_info(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be deleted (required) + :param username: The name that needs to be deleted (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -477,21 +521,26 @@ def get_user_by_name(self, username, **kwargs): # 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_user_by_name(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be fetched. Use user1 for testing. (required) + :param username: The name that needs to be fetched. Use user1 for testing. (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: User + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: User """ kwargs['_return_http_data_only'] = True return self.get_user_by_name_with_http_info(username, **kwargs) # noqa: E501 @@ -501,23 +550,29 @@ def get_user_by_name_with_http_info(self, username, **kwargs): # 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_user_by_name_with_http_info(username, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The name that needs to be fetched. Use user1 for testing. (required) + :param username: The name that needs to be fetched. Use user1 for testing. (required) + :type username: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(User, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(User, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -589,22 +644,28 @@ def login_user(self, username, password, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user(username, password, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The user name for login (required) - :param str password: The password for login in clear text (required) + :param username: The user name for login (required) + :type username: str + :param password: The password for login in clear text (required) + :type password: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: str + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: str """ kwargs['_return_http_data_only'] = True return self.login_user_with_http_info(username, password, **kwargs) # noqa: E501 @@ -614,24 +675,31 @@ def login_user_with_http_info(self, username, password, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.login_user_with_http_info(username, password, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: The user name for login (required) - :param str password: The password for login in clear text (required) + :param username: The user name for login (required) + :type username: str + :param password: The password for login in clear text (required) + :type password: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: tuple(str, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(str, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -710,20 +778,24 @@ def logout_user(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.logout_user_with_http_info(**kwargs) # noqa: E501 @@ -733,22 +805,27 @@ def logout_user_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.logout_user_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -810,22 +887,28 @@ def update_user(self, username, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user(username, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: name that need to be deleted (required) - :param User body: Updated user object (required) + :param username: name that need to be deleted (required) + :type username: str + :param body: Updated user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ kwargs['_return_http_data_only'] = True return self.update_user_with_http_info(username, body, **kwargs) # noqa: E501 @@ -836,24 +919,31 @@ def update_user_with_http_info(self, username, body, **kwargs): # noqa: E501 This can only be done by the logged in user. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.update_user_with_http_info(username, body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str username: name that need to be deleted (required) - :param User body: Updated user object (required) + :param username: name that need to be deleted (required) + :type username: str + :param body: Updated user object (required) + :type body: User + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_any_type.py b/samples/client/petstore/python/petstore_api/models/additional_properties_any_type.py index 2954285de87c..690c71705b9c 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_any_type.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_any_type.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesAnyType. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_array.py b/samples/client/petstore/python/petstore_api/models/additional_properties_array.py index c6369c22a12f..f0902bdaffac 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_array.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_array.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesArray. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_boolean.py b/samples/client/petstore/python/petstore_api/models/additional_properties_boolean.py index 599b7c8b8843..f79d2609a1df 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_boolean.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_boolean.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesBoolean. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_class.py b/samples/client/petstore/python/petstore_api/models/additional_properties_class.py index be4455c683bf..ca334635175d 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_class.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_class.py @@ -118,7 +118,7 @@ def map_string(self, map_string): :param map_string: The map_string of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, str) + :type map_string: dict(str, str) """ self._map_string = map_string @@ -139,7 +139,7 @@ def map_number(self, map_number): :param map_number: The map_number of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, float) + :type map_number: dict(str, float) """ self._map_number = map_number @@ -160,7 +160,7 @@ def map_integer(self, map_integer): :param map_integer: The map_integer of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, int) + :type map_integer: dict(str, int) """ self._map_integer = map_integer @@ -181,7 +181,7 @@ def map_boolean(self, map_boolean): :param map_boolean: The map_boolean of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, bool) + :type map_boolean: dict(str, bool) """ self._map_boolean = map_boolean @@ -202,7 +202,7 @@ def map_array_integer(self, map_array_integer): :param map_array_integer: The map_array_integer of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, list[int]) + :type map_array_integer: dict(str, list[int]) """ self._map_array_integer = map_array_integer @@ -223,7 +223,7 @@ def map_array_anytype(self, map_array_anytype): :param map_array_anytype: The map_array_anytype of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, list[object]) + :type map_array_anytype: dict(str, list[object]) """ self._map_array_anytype = map_array_anytype @@ -244,7 +244,7 @@ def map_map_string(self, map_map_string): :param map_map_string: The map_map_string of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, dict(str, str)) + :type map_map_string: dict(str, dict(str, str)) """ self._map_map_string = map_map_string @@ -265,7 +265,7 @@ def map_map_anytype(self, map_map_anytype): :param map_map_anytype: The map_map_anytype of this AdditionalPropertiesClass. # noqa: E501 - :type: dict(str, dict(str, object)) + :type map_map_anytype: dict(str, dict(str, object)) """ self._map_map_anytype = map_map_anytype @@ -286,7 +286,7 @@ def anytype_1(self, anytype_1): :param anytype_1: The anytype_1 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_1: object """ self._anytype_1 = anytype_1 @@ -307,7 +307,7 @@ def anytype_2(self, anytype_2): :param anytype_2: The anytype_2 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_2: object """ self._anytype_2 = anytype_2 @@ -328,7 +328,7 @@ def anytype_3(self, anytype_3): :param anytype_3: The anytype_3 of this AdditionalPropertiesClass. # noqa: E501 - :type: object + :type anytype_3: object """ self._anytype_3 = anytype_3 diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_integer.py b/samples/client/petstore/python/petstore_api/models/additional_properties_integer.py index ddbb85fdf33b..5c3ebf230d10 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_integer.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_integer.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesInteger. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_number.py b/samples/client/petstore/python/petstore_api/models/additional_properties_number.py index 8bbeda83ecca..0e7f34ed329f 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_number.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_number.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesNumber. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_object.py b/samples/client/petstore/python/petstore_api/models/additional_properties_object.py index af87595b3e41..5a8ea94b929b 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_object.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_object.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesObject. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/additional_properties_string.py b/samples/client/petstore/python/petstore_api/models/additional_properties_string.py index 6ab2c91feda9..8436a1e345b0 100644 --- a/samples/client/petstore/python/petstore_api/models/additional_properties_string.py +++ b/samples/client/petstore/python/petstore_api/models/additional_properties_string.py @@ -68,7 +68,7 @@ def name(self, name): :param name: The name of this AdditionalPropertiesString. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/animal.py b/samples/client/petstore/python/petstore_api/models/animal.py index b338e0eb18e9..eef35ab093ab 100644 --- a/samples/client/petstore/python/petstore_api/models/animal.py +++ b/samples/client/petstore/python/petstore_api/models/animal.py @@ -78,7 +78,7 @@ def class_name(self, class_name): :param class_name: The class_name of this Animal. # noqa: E501 - :type: str + :type class_name: str """ if self.local_vars_configuration.client_side_validation and class_name is None: # noqa: E501 raise ValueError("Invalid value for `class_name`, must not be `None`") # noqa: E501 @@ -101,7 +101,7 @@ def color(self, color): :param color: The color of this Animal. # noqa: E501 - :type: str + :type color: str """ self._color = color diff --git a/samples/client/petstore/python/petstore_api/models/api_response.py b/samples/client/petstore/python/petstore_api/models/api_response.py index 24e80d02aea4..8cb64673c354 100644 --- a/samples/client/petstore/python/petstore_api/models/api_response.py +++ b/samples/client/petstore/python/petstore_api/models/api_response.py @@ -78,7 +78,7 @@ def code(self, code): :param code: The code of this ApiResponse. # noqa: E501 - :type: int + :type code: int """ self._code = code @@ -99,7 +99,7 @@ def type(self, type): :param type: The type of this ApiResponse. # noqa: E501 - :type: str + :type type: str """ self._type = type @@ -120,7 +120,7 @@ def message(self, message): :param message: The message of this ApiResponse. # noqa: E501 - :type: str + :type message: str """ self._message = message diff --git a/samples/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py b/samples/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py index 1f654452077f..41a689c534ac 100644 --- a/samples/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py +++ b/samples/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py @@ -68,7 +68,7 @@ def array_array_number(self, array_array_number): :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 diff --git a/samples/client/petstore/python/petstore_api/models/array_of_number_only.py b/samples/client/petstore/python/petstore_api/models/array_of_number_only.py index 27ba1f58e31e..ddb7f7c7abe0 100644 --- a/samples/client/petstore/python/petstore_api/models/array_of_number_only.py +++ b/samples/client/petstore/python/petstore_api/models/array_of_number_only.py @@ -68,7 +68,7 @@ def array_number(self, array_number): :param array_number: The array_number of this ArrayOfNumberOnly. # noqa: E501 - :type: list[float] + :type array_number: list[float] """ self._array_number = array_number diff --git a/samples/client/petstore/python/petstore_api/models/array_test.py b/samples/client/petstore/python/petstore_api/models/array_test.py index f34a372f6f3b..e8e5c378f98e 100644 --- a/samples/client/petstore/python/petstore_api/models/array_test.py +++ b/samples/client/petstore/python/petstore_api/models/array_test.py @@ -78,7 +78,7 @@ def array_of_string(self, array_of_string): :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 @@ def array_array_of_integer(self, array_array_of_integer): :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 @@ def array_array_of_model(self, array_array_of_model): :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 diff --git a/samples/client/petstore/python/petstore_api/models/big_cat.py b/samples/client/petstore/python/petstore_api/models/big_cat.py index fe52c3650ac5..946981f5b7fa 100644 --- a/samples/client/petstore/python/petstore_api/models/big_cat.py +++ b/samples/client/petstore/python/petstore_api/models/big_cat.py @@ -68,7 +68,7 @@ def kind(self, kind): :param kind: The kind of this BigCat. # noqa: E501 - :type: str + :type kind: str """ allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501 if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501 diff --git a/samples/client/petstore/python/petstore_api/models/big_cat_all_of.py b/samples/client/petstore/python/petstore_api/models/big_cat_all_of.py index b75500db987e..41c205d2576f 100644 --- a/samples/client/petstore/python/petstore_api/models/big_cat_all_of.py +++ b/samples/client/petstore/python/petstore_api/models/big_cat_all_of.py @@ -68,7 +68,7 @@ def kind(self, kind): :param kind: The kind of this BigCatAllOf. # noqa: E501 - :type: str + :type kind: str """ allowed_values = ["lions", "tigers", "leopards", "jaguars"] # noqa: E501 if self.local_vars_configuration.client_side_validation and kind not in allowed_values: # noqa: E501 diff --git a/samples/client/petstore/python/petstore_api/models/capitalization.py b/samples/client/petstore/python/petstore_api/models/capitalization.py index cef34c5f6dc3..967d324a0ab0 100644 --- a/samples/client/petstore/python/petstore_api/models/capitalization.py +++ b/samples/client/petstore/python/petstore_api/models/capitalization.py @@ -93,7 +93,7 @@ def small_camel(self, small_camel): :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 @@ def capital_camel(self, capital_camel): :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 @@ def small_snake(self, small_snake): :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 @@ def capital_snake(self, capital_snake): :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 @@ def sca_eth_flow_points(self, sca_eth_flow_points): :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 @@ def att_name(self, att_name): 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 diff --git a/samples/client/petstore/python/petstore_api/models/cat.py b/samples/client/petstore/python/petstore_api/models/cat.py index e39c1c82508c..b3b0d868c7f0 100644 --- a/samples/client/petstore/python/petstore_api/models/cat.py +++ b/samples/client/petstore/python/petstore_api/models/cat.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this Cat. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/client/petstore/python/petstore_api/models/cat_all_of.py b/samples/client/petstore/python/petstore_api/models/cat_all_of.py index 7e90fab93489..f573a04636c1 100644 --- a/samples/client/petstore/python/petstore_api/models/cat_all_of.py +++ b/samples/client/petstore/python/petstore_api/models/cat_all_of.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this CatAllOf. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/client/petstore/python/petstore_api/models/category.py b/samples/client/petstore/python/petstore_api/models/category.py index b47c148953ea..11a7bf85f3ad 100644 --- a/samples/client/petstore/python/petstore_api/models/category.py +++ b/samples/client/petstore/python/petstore_api/models/category.py @@ -72,7 +72,7 @@ def id(self, id): :param id: The id of this Category. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -93,7 +93,7 @@ def name(self, name): :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 diff --git a/samples/client/petstore/python/petstore_api/models/class_model.py b/samples/client/petstore/python/petstore_api/models/class_model.py index ef6060ffa70d..aac505ea064d 100644 --- a/samples/client/petstore/python/petstore_api/models/class_model.py +++ b/samples/client/petstore/python/petstore_api/models/class_model.py @@ -68,7 +68,7 @@ def _class(self, _class): :param _class: The _class of this ClassModel. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/client/petstore/python/petstore_api/models/client.py b/samples/client/petstore/python/petstore_api/models/client.py index ee5dbf1c43a1..2006350b2109 100644 --- a/samples/client/petstore/python/petstore_api/models/client.py +++ b/samples/client/petstore/python/petstore_api/models/client.py @@ -68,7 +68,7 @@ def client(self, client): :param client: The client of this Client. # noqa: E501 - :type: str + :type client: str """ self._client = client diff --git a/samples/client/petstore/python/petstore_api/models/dog.py b/samples/client/petstore/python/petstore_api/models/dog.py index eacb63eedb09..fb9024d0bb76 100644 --- a/samples/client/petstore/python/petstore_api/models/dog.py +++ b/samples/client/petstore/python/petstore_api/models/dog.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this Dog. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/client/petstore/python/petstore_api/models/dog_all_of.py b/samples/client/petstore/python/petstore_api/models/dog_all_of.py index 48e048557085..5943ba900dd6 100644 --- a/samples/client/petstore/python/petstore_api/models/dog_all_of.py +++ b/samples/client/petstore/python/petstore_api/models/dog_all_of.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this DogAllOf. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/client/petstore/python/petstore_api/models/enum_arrays.py b/samples/client/petstore/python/petstore_api/models/enum_arrays.py index 819ff322157d..ae2ea1d42511 100644 --- a/samples/client/petstore/python/petstore_api/models/enum_arrays.py +++ b/samples/client/petstore/python/petstore_api/models/enum_arrays.py @@ -73,7 +73,7 @@ def just_symbol(self, just_symbol): :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 @@ def array_enum(self, array_enum): :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 diff --git a/samples/client/petstore/python/petstore_api/models/enum_test.py b/samples/client/petstore/python/petstore_api/models/enum_test.py index 464281b3ec0e..e9872c4d005a 100644 --- a/samples/client/petstore/python/petstore_api/models/enum_test.py +++ b/samples/client/petstore/python/petstore_api/models/enum_test.py @@ -87,7 +87,7 @@ def enum_string(self, enum_string): :param enum_string: The enum_string of this EnumTest. # noqa: E501 - :type: str + :type enum_string: str """ allowed_values = ["UPPER", "lower", ""] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_string not in allowed_values: # noqa: E501 @@ -114,7 +114,7 @@ def enum_string_required(self, enum_string_required): :param enum_string_required: The enum_string_required of this EnumTest. # noqa: E501 - :type: str + :type enum_string_required: str """ if self.local_vars_configuration.client_side_validation and enum_string_required is None: # noqa: E501 raise ValueError("Invalid value for `enum_string_required`, must not be `None`") # noqa: E501 @@ -143,7 +143,7 @@ def enum_integer(self, enum_integer): :param enum_integer: The enum_integer of this EnumTest. # noqa: E501 - :type: int + :type enum_integer: int """ allowed_values = [1, -1] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_integer not in allowed_values: # noqa: E501 @@ -170,7 +170,7 @@ def enum_number(self, enum_number): :param enum_number: The enum_number of this EnumTest. # noqa: E501 - :type: float + :type enum_number: float """ allowed_values = [1.1, -1.2] # noqa: E501 if self.local_vars_configuration.client_side_validation and enum_number not in allowed_values: # noqa: E501 @@ -197,7 +197,7 @@ def outer_enum(self, outer_enum): :param outer_enum: The outer_enum of this EnumTest. # noqa: E501 - :type: OuterEnum + :type outer_enum: OuterEnum """ self._outer_enum = outer_enum diff --git a/samples/client/petstore/python/petstore_api/models/file.py b/samples/client/petstore/python/petstore_api/models/file.py index 282df2957e67..4fb5c31762e8 100644 --- a/samples/client/petstore/python/petstore_api/models/file.py +++ b/samples/client/petstore/python/petstore_api/models/file.py @@ -70,7 +70,7 @@ def source_uri(self, source_uri): 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 diff --git a/samples/client/petstore/python/petstore_api/models/file_schema_test_class.py b/samples/client/petstore/python/petstore_api/models/file_schema_test_class.py index de7f865b47e2..2f2d44a7b33d 100644 --- a/samples/client/petstore/python/petstore_api/models/file_schema_test_class.py +++ b/samples/client/petstore/python/petstore_api/models/file_schema_test_class.py @@ -73,7 +73,7 @@ def file(self, file): :param file: The file of this FileSchemaTestClass. # noqa: E501 - :type: File + :type file: File """ self._file = file @@ -94,7 +94,7 @@ def files(self, files): :param files: The files of this FileSchemaTestClass. # noqa: E501 - :type: list[File] + :type files: list[File] """ self._files = files diff --git a/samples/client/petstore/python/petstore_api/models/format_test.py b/samples/client/petstore/python/petstore_api/models/format_test.py index 6396c442f624..c96f8132fa61 100644 --- a/samples/client/petstore/python/petstore_api/models/format_test.py +++ b/samples/client/petstore/python/petstore_api/models/format_test.py @@ -129,7 +129,7 @@ def integer(self, integer): :param integer: The integer of this FormatTest. # noqa: E501 - :type: int + :type integer: int """ if (self.local_vars_configuration.client_side_validation and integer is not None and integer > 100): # noqa: E501 @@ -156,7 +156,7 @@ def int32(self, int32): :param int32: The int32 of this FormatTest. # noqa: E501 - :type: int + :type int32: int """ if (self.local_vars_configuration.client_side_validation and int32 is not None and int32 > 200): # noqa: E501 @@ -183,7 +183,7 @@ def int64(self, int64): :param int64: The int64 of this FormatTest. # noqa: E501 - :type: int + :type int64: int """ self._int64 = int64 @@ -204,7 +204,7 @@ def number(self, number): :param number: The number of this FormatTest. # noqa: E501 - :type: float + :type number: float """ if self.local_vars_configuration.client_side_validation and number is None: # noqa: E501 raise ValueError("Invalid value for `number`, must not be `None`") # noqa: E501 @@ -233,7 +233,7 @@ def float(self, float): :param float: The float of this FormatTest. # noqa: E501 - :type: float + :type float: float """ if (self.local_vars_configuration.client_side_validation and float is not None and float > 987.6): # noqa: E501 @@ -260,7 +260,7 @@ def double(self, double): :param double: The double of this FormatTest. # noqa: E501 - :type: float + :type double: float """ if (self.local_vars_configuration.client_side_validation and double is not None and double > 123.4): # noqa: E501 @@ -287,7 +287,7 @@ def string(self, string): :param string: The string of this FormatTest. # noqa: E501 - :type: str + :type string: str """ if (self.local_vars_configuration.client_side_validation and string is not None and not re.search(r'[a-z]', string, flags=re.IGNORECASE)): # noqa: E501 @@ -311,7 +311,7 @@ def byte(self, byte): :param byte: The byte of this FormatTest. # noqa: E501 - :type: str + :type byte: str """ if self.local_vars_configuration.client_side_validation and byte is None: # noqa: E501 raise ValueError("Invalid value for `byte`, must not be `None`") # noqa: E501 @@ -337,7 +337,7 @@ def binary(self, binary): :param binary: The binary of this FormatTest. # noqa: E501 - :type: file + :type binary: file """ self._binary = binary @@ -358,7 +358,7 @@ def date(self, date): :param date: The date of this FormatTest. # noqa: E501 - :type: date + :type date: date """ if self.local_vars_configuration.client_side_validation and date is None: # noqa: E501 raise ValueError("Invalid value for `date`, must not be `None`") # noqa: E501 @@ -381,7 +381,7 @@ def date_time(self, date_time): :param date_time: The date_time of this FormatTest. # noqa: E501 - :type: datetime + :type date_time: datetime """ self._date_time = date_time @@ -402,7 +402,7 @@ def uuid(self, uuid): :param uuid: The uuid of this FormatTest. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -423,7 +423,7 @@ def password(self, password): :param password: The password of this FormatTest. # noqa: E501 - :type: str + :type password: str """ if self.local_vars_configuration.client_side_validation and password is None: # noqa: E501 raise ValueError("Invalid value for `password`, must not be `None`") # noqa: E501 @@ -452,7 +452,7 @@ def big_decimal(self, big_decimal): :param big_decimal: The big_decimal of this FormatTest. # noqa: E501 - :type: BigDecimal + :type big_decimal: BigDecimal """ self._big_decimal = big_decimal diff --git a/samples/client/petstore/python/petstore_api/models/has_only_read_only.py b/samples/client/petstore/python/petstore_api/models/has_only_read_only.py index 5fc2f8a9ebdd..fa496519ecb2 100644 --- a/samples/client/petstore/python/petstore_api/models/has_only_read_only.py +++ b/samples/client/petstore/python/petstore_api/models/has_only_read_only.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def foo(self, foo): :param foo: The foo of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type foo: str """ self._foo = foo diff --git a/samples/client/petstore/python/petstore_api/models/list.py b/samples/client/petstore/python/petstore_api/models/list.py index d58d13e90fbc..e21a220f71cd 100644 --- a/samples/client/petstore/python/petstore_api/models/list.py +++ b/samples/client/petstore/python/petstore_api/models/list.py @@ -68,7 +68,7 @@ def _123_list(self, _123_list): :param _123_list: The _123_list of this List. # noqa: E501 - :type: str + :type _123_list: str """ self.__123_list = _123_list diff --git a/samples/client/petstore/python/petstore_api/models/map_test.py b/samples/client/petstore/python/petstore_api/models/map_test.py index f0cfba5073b0..8afc875ce517 100644 --- a/samples/client/petstore/python/petstore_api/models/map_test.py +++ b/samples/client/petstore/python/petstore_api/models/map_test.py @@ -83,7 +83,7 @@ def map_map_of_string(self, map_map_of_string): :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 @@ def map_of_enum_string(self, map_of_enum_string): :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 @@ def direct_map(self, direct_map): :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 @@ def indirect_map(self, indirect_map): :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 diff --git a/samples/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py b/samples/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py index 5da34f8830e8..8aecbf0f558a 100644 --- a/samples/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py +++ b/samples/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py @@ -78,7 +78,7 @@ def uuid(self, uuid): :param uuid: The uuid of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -99,7 +99,7 @@ def date_time(self, date_time): :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 @@ def map(self, map): :param map: The map of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: dict(str, Animal) + :type map: dict(str, Animal) """ self._map = map diff --git a/samples/client/petstore/python/petstore_api/models/model200_response.py b/samples/client/petstore/python/petstore_api/models/model200_response.py index 841ce1f18f3d..3f4c4e2bd2a7 100644 --- a/samples/client/petstore/python/petstore_api/models/model200_response.py +++ b/samples/client/petstore/python/petstore_api/models/model200_response.py @@ -73,7 +73,7 @@ def name(self, name): :param name: The name of this Model200Response. # noqa: E501 - :type: int + :type name: int """ self._name = name @@ -94,7 +94,7 @@ def _class(self, _class): :param _class: The _class of this Model200Response. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/client/petstore/python/petstore_api/models/model_return.py b/samples/client/petstore/python/petstore_api/models/model_return.py index fdd8d72314ad..1009c50ef08e 100644 --- a/samples/client/petstore/python/petstore_api/models/model_return.py +++ b/samples/client/petstore/python/petstore_api/models/model_return.py @@ -68,7 +68,7 @@ def _return(self, _return): :param _return: The _return of this ModelReturn. # noqa: E501 - :type: int + :type _return: int """ self.__return = _return diff --git a/samples/client/petstore/python/petstore_api/models/name.py b/samples/client/petstore/python/petstore_api/models/name.py index bb2c1fbd73cc..6ee8261e7821 100644 --- a/samples/client/petstore/python/petstore_api/models/name.py +++ b/samples/client/petstore/python/petstore_api/models/name.py @@ -82,7 +82,7 @@ def name(self, name): :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 @@ def snake_case(self, snake_case): :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 @@ def _property(self, _property): :param _property: The _property of this Name. # noqa: E501 - :type: str + :type _property: str """ self.__property = _property @@ -147,7 +147,7 @@ def _123_number(self, _123_number): :param _123_number: The _123_number of this Name. # noqa: E501 - :type: int + :type _123_number: int """ self.__123_number = _123_number diff --git a/samples/client/petstore/python/petstore_api/models/number_only.py b/samples/client/petstore/python/petstore_api/models/number_only.py index 99b2424852fb..90f09d8b7d56 100644 --- a/samples/client/petstore/python/petstore_api/models/number_only.py +++ b/samples/client/petstore/python/petstore_api/models/number_only.py @@ -68,7 +68,7 @@ def just_number(self, just_number): :param just_number: The just_number of this NumberOnly. # noqa: E501 - :type: float + :type just_number: float """ self._just_number = just_number diff --git a/samples/client/petstore/python/petstore_api/models/order.py b/samples/client/petstore/python/petstore_api/models/order.py index 8c863cce8fe5..8f298aa3d9c2 100644 --- a/samples/client/petstore/python/petstore_api/models/order.py +++ b/samples/client/petstore/python/petstore_api/models/order.py @@ -93,7 +93,7 @@ def id(self, id): :param id: The id of this Order. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -114,7 +114,7 @@ def pet_id(self, pet_id): :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 @@ def quantity(self, quantity): :param quantity: The quantity of this Order. # noqa: E501 - :type: int + :type quantity: int """ self._quantity = quantity @@ -156,7 +156,7 @@ def ship_date(self, ship_date): :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 @@ def status(self, status): 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 @@ def complete(self, complete): :param complete: The complete of this Order. # noqa: E501 - :type: bool + :type complete: bool """ self._complete = complete diff --git a/samples/client/petstore/python/petstore_api/models/outer_composite.py b/samples/client/petstore/python/petstore_api/models/outer_composite.py index c11859114a57..85fe36c7ef07 100644 --- a/samples/client/petstore/python/petstore_api/models/outer_composite.py +++ b/samples/client/petstore/python/petstore_api/models/outer_composite.py @@ -78,7 +78,7 @@ def my_number(self, my_number): :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 @@ def my_string(self, my_string): :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 @@ def my_boolean(self, my_boolean): :param my_boolean: The my_boolean of this OuterComposite. # noqa: E501 - :type: bool + :type my_boolean: bool """ self._my_boolean = my_boolean diff --git a/samples/client/petstore/python/petstore_api/models/pet.py b/samples/client/petstore/python/petstore_api/models/pet.py index edbf73f53127..b948a6436db1 100644 --- a/samples/client/petstore/python/petstore_api/models/pet.py +++ b/samples/client/petstore/python/petstore_api/models/pet.py @@ -91,7 +91,7 @@ def id(self, id): :param id: The id of this Pet. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -112,7 +112,7 @@ def category(self, category): :param category: The category of this Pet. # noqa: E501 - :type: Category + :type category: Category """ self._category = category @@ -133,7 +133,7 @@ def name(self, name): :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 @@ def photo_urls(self, photo_urls): :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 @@ def tags(self, tags): :param tags: The tags of this Pet. # noqa: E501 - :type: list[Tag] + :type tags: list[Tag] """ self._tags = tags @@ -202,7 +202,7 @@ def status(self, status): 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 diff --git a/samples/client/petstore/python/petstore_api/models/read_only_first.py b/samples/client/petstore/python/petstore_api/models/read_only_first.py index a84679e98dee..3a305087dc26 100644 --- a/samples/client/petstore/python/petstore_api/models/read_only_first.py +++ b/samples/client/petstore/python/petstore_api/models/read_only_first.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this ReadOnlyFirst. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def baz(self, baz): :param baz: The baz of this ReadOnlyFirst. # noqa: E501 - :type: str + :type baz: str """ self._baz = baz diff --git a/samples/client/petstore/python/petstore_api/models/special_model_name.py b/samples/client/petstore/python/petstore_api/models/special_model_name.py index 396e75bcee5c..d2535eb65aca 100644 --- a/samples/client/petstore/python/petstore_api/models/special_model_name.py +++ b/samples/client/petstore/python/petstore_api/models/special_model_name.py @@ -68,7 +68,7 @@ def special_property_name(self, special_property_name): :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 diff --git a/samples/client/petstore/python/petstore_api/models/tag.py b/samples/client/petstore/python/petstore_api/models/tag.py index d6137fdd47f0..7492d30d9eb6 100644 --- a/samples/client/petstore/python/petstore_api/models/tag.py +++ b/samples/client/petstore/python/petstore_api/models/tag.py @@ -73,7 +73,7 @@ def id(self, id): :param id: The id of this Tag. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -94,7 +94,7 @@ def name(self, name): :param name: The name of this Tag. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/client/petstore/python/petstore_api/models/type_holder_default.py b/samples/client/petstore/python/petstore_api/models/type_holder_default.py index 8163ea77aa73..fbef6b4b1574 100644 --- a/samples/client/petstore/python/petstore_api/models/type_holder_default.py +++ b/samples/client/petstore/python/petstore_api/models/type_holder_default.py @@ -83,7 +83,7 @@ def string_item(self, string_item): :param string_item: The string_item of this TypeHolderDefault. # noqa: E501 - :type: str + :type string_item: str """ if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501 raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501 @@ -106,7 +106,7 @@ def number_item(self, number_item): :param number_item: The number_item of this TypeHolderDefault. # noqa: E501 - :type: float + :type number_item: float """ if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501 raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501 @@ -129,7 +129,7 @@ def integer_item(self, integer_item): :param integer_item: The integer_item of this TypeHolderDefault. # noqa: E501 - :type: int + :type integer_item: int """ if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501 raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501 @@ -152,7 +152,7 @@ def bool_item(self, bool_item): :param bool_item: The bool_item of this TypeHolderDefault. # noqa: E501 - :type: bool + :type bool_item: bool """ if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501 raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501 @@ -175,7 +175,7 @@ def array_item(self, array_item): :param array_item: The array_item of this TypeHolderDefault. # noqa: E501 - :type: list[int] + :type array_item: list[int] """ if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501 raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501 diff --git a/samples/client/petstore/python/petstore_api/models/type_holder_example.py b/samples/client/petstore/python/petstore_api/models/type_holder_example.py index 34481fd21e31..b7320bed0ca7 100644 --- a/samples/client/petstore/python/petstore_api/models/type_holder_example.py +++ b/samples/client/petstore/python/petstore_api/models/type_holder_example.py @@ -87,7 +87,7 @@ def string_item(self, string_item): :param string_item: The string_item of this TypeHolderExample. # noqa: E501 - :type: str + :type string_item: str """ if self.local_vars_configuration.client_side_validation and string_item is None: # noqa: E501 raise ValueError("Invalid value for `string_item`, must not be `None`") # noqa: E501 @@ -110,7 +110,7 @@ def number_item(self, number_item): :param number_item: The number_item of this TypeHolderExample. # noqa: E501 - :type: float + :type number_item: float """ if self.local_vars_configuration.client_side_validation and number_item is None: # noqa: E501 raise ValueError("Invalid value for `number_item`, must not be `None`") # noqa: E501 @@ -133,7 +133,7 @@ def float_item(self, float_item): :param float_item: The float_item of this TypeHolderExample. # noqa: E501 - :type: float + :type float_item: float """ if self.local_vars_configuration.client_side_validation and float_item is None: # noqa: E501 raise ValueError("Invalid value for `float_item`, must not be `None`") # noqa: E501 @@ -156,7 +156,7 @@ def integer_item(self, integer_item): :param integer_item: The integer_item of this TypeHolderExample. # noqa: E501 - :type: int + :type integer_item: int """ if self.local_vars_configuration.client_side_validation and integer_item is None: # noqa: E501 raise ValueError("Invalid value for `integer_item`, must not be `None`") # noqa: E501 @@ -179,7 +179,7 @@ def bool_item(self, bool_item): :param bool_item: The bool_item of this TypeHolderExample. # noqa: E501 - :type: bool + :type bool_item: bool """ if self.local_vars_configuration.client_side_validation and bool_item is None: # noqa: E501 raise ValueError("Invalid value for `bool_item`, must not be `None`") # noqa: E501 @@ -202,7 +202,7 @@ def array_item(self, array_item): :param array_item: The array_item of this TypeHolderExample. # noqa: E501 - :type: list[int] + :type array_item: list[int] """ if self.local_vars_configuration.client_side_validation and array_item is None: # noqa: E501 raise ValueError("Invalid value for `array_item`, must not be `None`") # noqa: E501 diff --git a/samples/client/petstore/python/petstore_api/models/user.py b/samples/client/petstore/python/petstore_api/models/user.py index de88bda4cde7..0e25f9f17104 100644 --- a/samples/client/petstore/python/petstore_api/models/user.py +++ b/samples/client/petstore/python/petstore_api/models/user.py @@ -103,7 +103,7 @@ def id(self, id): :param id: The id of this User. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -124,7 +124,7 @@ def username(self, username): :param username: The username of this User. # noqa: E501 - :type: str + :type username: str """ self._username = username @@ -145,7 +145,7 @@ def first_name(self, first_name): :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 @@ def last_name(self, last_name): :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 @@ def email(self, email): :param email: The email of this User. # noqa: E501 - :type: str + :type email: str """ self._email = email @@ -208,7 +208,7 @@ def password(self, password): :param password: The password of this User. # noqa: E501 - :type: str + :type password: str """ self._password = password @@ -229,7 +229,7 @@ def phone(self, phone): :param phone: The phone of this User. # noqa: E501 - :type: str + :type phone: str """ self._phone = phone @@ -252,7 +252,7 @@ def user_status(self, user_status): 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 diff --git a/samples/client/petstore/python/petstore_api/models/xml_item.py b/samples/client/petstore/python/petstore_api/models/xml_item.py index 52ecc9aa5225..afb75967cb0b 100644 --- a/samples/client/petstore/python/petstore_api/models/xml_item.py +++ b/samples/client/petstore/python/petstore_api/models/xml_item.py @@ -208,7 +208,7 @@ def attribute_string(self, attribute_string): :param attribute_string: The attribute_string of this XmlItem. # noqa: E501 - :type: str + :type attribute_string: str """ self._attribute_string = attribute_string @@ -229,7 +229,7 @@ def attribute_number(self, attribute_number): :param attribute_number: The attribute_number of this XmlItem. # noqa: E501 - :type: float + :type attribute_number: float """ self._attribute_number = attribute_number @@ -250,7 +250,7 @@ def attribute_integer(self, attribute_integer): :param attribute_integer: The attribute_integer of this XmlItem. # noqa: E501 - :type: int + :type attribute_integer: int """ self._attribute_integer = attribute_integer @@ -271,7 +271,7 @@ def attribute_boolean(self, attribute_boolean): :param attribute_boolean: The attribute_boolean of this XmlItem. # noqa: E501 - :type: bool + :type attribute_boolean: bool """ self._attribute_boolean = attribute_boolean @@ -292,7 +292,7 @@ def wrapped_array(self, wrapped_array): :param wrapped_array: The wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type wrapped_array: list[int] """ self._wrapped_array = wrapped_array @@ -313,7 +313,7 @@ def name_string(self, name_string): :param name_string: The name_string of this XmlItem. # noqa: E501 - :type: str + :type name_string: str """ self._name_string = name_string @@ -334,7 +334,7 @@ def name_number(self, name_number): :param name_number: The name_number of this XmlItem. # noqa: E501 - :type: float + :type name_number: float """ self._name_number = name_number @@ -355,7 +355,7 @@ def name_integer(self, name_integer): :param name_integer: The name_integer of this XmlItem. # noqa: E501 - :type: int + :type name_integer: int """ self._name_integer = name_integer @@ -376,7 +376,7 @@ def name_boolean(self, name_boolean): :param name_boolean: The name_boolean of this XmlItem. # noqa: E501 - :type: bool + :type name_boolean: bool """ self._name_boolean = name_boolean @@ -397,7 +397,7 @@ def name_array(self, name_array): :param name_array: The name_array of this XmlItem. # noqa: E501 - :type: list[int] + :type name_array: list[int] """ self._name_array = name_array @@ -418,7 +418,7 @@ def name_wrapped_array(self, name_wrapped_array): :param name_wrapped_array: The name_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type name_wrapped_array: list[int] """ self._name_wrapped_array = name_wrapped_array @@ -439,7 +439,7 @@ def prefix_string(self, prefix_string): :param prefix_string: The prefix_string of this XmlItem. # noqa: E501 - :type: str + :type prefix_string: str """ self._prefix_string = prefix_string @@ -460,7 +460,7 @@ def prefix_number(self, prefix_number): :param prefix_number: The prefix_number of this XmlItem. # noqa: E501 - :type: float + :type prefix_number: float """ self._prefix_number = prefix_number @@ -481,7 +481,7 @@ def prefix_integer(self, prefix_integer): :param prefix_integer: The prefix_integer of this XmlItem. # noqa: E501 - :type: int + :type prefix_integer: int """ self._prefix_integer = prefix_integer @@ -502,7 +502,7 @@ def prefix_boolean(self, prefix_boolean): :param prefix_boolean: The prefix_boolean of this XmlItem. # noqa: E501 - :type: bool + :type prefix_boolean: bool """ self._prefix_boolean = prefix_boolean @@ -523,7 +523,7 @@ def prefix_array(self, prefix_array): :param prefix_array: The prefix_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_array: list[int] """ self._prefix_array = prefix_array @@ -544,7 +544,7 @@ def prefix_wrapped_array(self, prefix_wrapped_array): :param prefix_wrapped_array: The prefix_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_wrapped_array: list[int] """ self._prefix_wrapped_array = prefix_wrapped_array @@ -565,7 +565,7 @@ def namespace_string(self, namespace_string): :param namespace_string: The namespace_string of this XmlItem. # noqa: E501 - :type: str + :type namespace_string: str """ self._namespace_string = namespace_string @@ -586,7 +586,7 @@ def namespace_number(self, namespace_number): :param namespace_number: The namespace_number of this XmlItem. # noqa: E501 - :type: float + :type namespace_number: float """ self._namespace_number = namespace_number @@ -607,7 +607,7 @@ def namespace_integer(self, namespace_integer): :param namespace_integer: The namespace_integer of this XmlItem. # noqa: E501 - :type: int + :type namespace_integer: int """ self._namespace_integer = namespace_integer @@ -628,7 +628,7 @@ def namespace_boolean(self, namespace_boolean): :param namespace_boolean: The namespace_boolean of this XmlItem. # noqa: E501 - :type: bool + :type namespace_boolean: bool """ self._namespace_boolean = namespace_boolean @@ -649,7 +649,7 @@ def namespace_array(self, namespace_array): :param namespace_array: The namespace_array of this XmlItem. # noqa: E501 - :type: list[int] + :type namespace_array: list[int] """ self._namespace_array = namespace_array @@ -670,7 +670,7 @@ def namespace_wrapped_array(self, namespace_wrapped_array): :param namespace_wrapped_array: The namespace_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type namespace_wrapped_array: list[int] """ self._namespace_wrapped_array = namespace_wrapped_array @@ -691,7 +691,7 @@ def prefix_ns_string(self, prefix_ns_string): :param prefix_ns_string: The prefix_ns_string of this XmlItem. # noqa: E501 - :type: str + :type prefix_ns_string: str """ self._prefix_ns_string = prefix_ns_string @@ -712,7 +712,7 @@ def prefix_ns_number(self, prefix_ns_number): :param prefix_ns_number: The prefix_ns_number of this XmlItem. # noqa: E501 - :type: float + :type prefix_ns_number: float """ self._prefix_ns_number = prefix_ns_number @@ -733,7 +733,7 @@ def prefix_ns_integer(self, prefix_ns_integer): :param prefix_ns_integer: The prefix_ns_integer of this XmlItem. # noqa: E501 - :type: int + :type prefix_ns_integer: int """ self._prefix_ns_integer = prefix_ns_integer @@ -754,7 +754,7 @@ def prefix_ns_boolean(self, prefix_ns_boolean): :param prefix_ns_boolean: The prefix_ns_boolean of this XmlItem. # noqa: E501 - :type: bool + :type prefix_ns_boolean: bool """ self._prefix_ns_boolean = prefix_ns_boolean @@ -775,7 +775,7 @@ def prefix_ns_array(self, prefix_ns_array): :param prefix_ns_array: The prefix_ns_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_ns_array: list[int] """ self._prefix_ns_array = prefix_ns_array @@ -796,7 +796,7 @@ def prefix_ns_wrapped_array(self, prefix_ns_wrapped_array): :param prefix_ns_wrapped_array: The prefix_ns_wrapped_array of this XmlItem. # noqa: E501 - :type: list[int] + :type prefix_ns_wrapped_array: list[int] """ self._prefix_ns_wrapped_array = prefix_ns_wrapped_array diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/another_fake_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/another_fake_api.py index cb2881b7ae8c..7aebc264b071 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/another_fake_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/another_fake_api.py @@ -59,6 +59,7 @@ def __call_123_test_special_tags( 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_client, async_req=True) >>> result = thread.get() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/default_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/default_api.py index 25c8e40e5252..65d9c2178a80 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/default_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/default_api.py @@ -57,6 +57,7 @@ def __foo_get( 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() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_api.py index 3c5de6178be2..50c380e86073 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_api.py @@ -62,6 +62,7 @@ def __fake_health_get( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_health_get(async_req=True) >>> result = thread.get() @@ -166,6 +167,7 @@ def __fake_outer_boolean_serialize( Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize(async_req=True) >>> result = thread.get() @@ -277,6 +279,7 @@ def __fake_outer_composite_serialize( Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize(async_req=True) >>> result = thread.get() @@ -388,6 +391,7 @@ def __fake_outer_number_serialize( Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize(async_req=True) >>> result = thread.get() @@ -499,6 +503,7 @@ def __fake_outer_string_serialize( Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize(async_req=True) >>> result = thread.get() @@ -714,6 +719,7 @@ def __test_body_with_file_schema( For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema(file_schema_test_class_file_schema_test_class, async_req=True) >>> result = thread.get() @@ -829,6 +835,7 @@ def __test_body_with_query_params( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params(query, user_user, async_req=True) >>> result = thread.get() @@ -953,6 +960,7 @@ def __test_client_model( To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model(client_client, async_req=True) >>> result = thread.get() @@ -1073,6 +1081,7 @@ def __test_endpoint_parameters( Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() @@ -1326,6 +1335,7 @@ def __test_enum_parameters( To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters(async_req=True) >>> result = thread.get() @@ -1535,6 +1545,7 @@ def __test_group_parameters( Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() @@ -1686,6 +1697,7 @@ def __test_inline_additional_properties( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties(request_body, async_req=True) >>> result = thread.get() @@ -1801,6 +1813,7 @@ def __test_json_form_data( This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_json_form_data(param, param2, async_req=True) >>> result = thread.get() @@ -1930,6 +1943,7 @@ def __test_query_parameter_collection_format( To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py index 2ed92b4d0f33..e22f47b416c0 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/fake_classname_tags_123_api.py @@ -59,6 +59,7 @@ def __test_classname( 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_client, async_req=True) >>> result = thread.get() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/pet_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/pet_api.py index 9ccaf11c268d..9ca9a64f8e2d 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/pet_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/pet_api.py @@ -59,6 +59,7 @@ def __add_pet( 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_pet, async_req=True) >>> result = thread.get() @@ -180,6 +181,7 @@ def __delete_pet( 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() @@ -302,6 +304,7 @@ def __find_pets_by_status( 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() @@ -430,6 +433,7 @@ def __find_pets_by_tags( 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() @@ -551,6 +555,7 @@ def __get_pet_by_id( 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() @@ -669,6 +674,7 @@ def __update_pet( 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_pet, async_req=True) >>> result = thread.get() @@ -790,6 +796,7 @@ def __update_pet_with_form( 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() @@ -919,6 +926,7 @@ def __upload_file( 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() @@ -1051,6 +1059,7 @@ def __upload_file_with_required_file( 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() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/store_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/store_api.py index 67648f5ee722..5bd88ecdca16 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/store_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/store_api.py @@ -59,6 +59,7 @@ def __delete_order( For valid response try integer IDs with value < 1000. Anything above 1000 or nonintegers will generate API errors # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.delete_order(order_id, async_req=True) >>> result = thread.get() @@ -172,6 +173,7 @@ def __get_inventory( Returns a map of status codes to quantities # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_inventory(async_req=True) >>> result = thread.get() @@ -279,6 +281,7 @@ def __get_order_by_id( For valid response try integer IDs with value <= 5 or > 10. Other values will generated exceptions # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.get_order_by_id(order_id, async_req=True) >>> result = thread.get() @@ -401,6 +404,7 @@ def __place_order( 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_order, async_req=True) >>> result = thread.get() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/user_api.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/user_api.py index e5f5ffe886c9..46f1fdf79cae 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api/user_api.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api/user_api.py @@ -59,6 +59,7 @@ def __create_user( 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_user, async_req=True) >>> result = thread.get() @@ -173,6 +174,7 @@ def __create_users_with_array_input( 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_user, async_req=True) >>> result = thread.get() @@ -287,6 +289,7 @@ def __create_users_with_list_input( 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_user, async_req=True) >>> result = thread.get() @@ -402,6 +405,7 @@ def __delete_user( 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() @@ -515,6 +519,7 @@ def __get_user_by_name( 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() @@ -632,6 +637,7 @@ def __login_user( 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() @@ -756,6 +762,7 @@ def __logout_user( 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() @@ -860,6 +867,7 @@ def __update_user( 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_user, async_req=True) >>> result = thread.get() diff --git a/samples/openapi3/client/petstore/python-experimental/petstore_api/api_client.py b/samples/openapi3/client/petstore/python-experimental/petstore_api/api_client.py index 1edccecef670..7a7158d2c0b8 100644 --- a/samples/openapi3/client/petstore/python-experimental/petstore_api/api_client.py +++ b/samples/openapi3/client/petstore/python-experimental/petstore_api/api_client.py @@ -279,6 +279,7 @@ def deserialize(self, response, response_type, _check_type): ({str: (bool, str, int, float, date, datetime, str, none_type)},) :param _check_type: boolean, whether to check the types of the data received from the server + :type _check_type: bool :return: deserialized object. """ @@ -338,22 +339,28 @@ def call_api(self, resource_path, method, (float, none_type) ([int, none_type],) ({str: (bool, str, int, float, date, datetime, str, none_type)},) - :param files dict: key -> field name, value -> a list of open file + :param files: key -> field name, value -> a list of open file objects for `multipart/form-data`. + :type files: dict :param async_req bool: execute request asynchronously + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param collection_formats: dict of collection formats for path, query, header, and post parameters. + :type collection_formats: dict, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. :param _check_type: boolean describing if the data back from the server should have its type checked. + :type _check_type: bool, optional :return: If async_req parameter is True, the request will be called asynchronously. @@ -547,9 +554,9 @@ def update_params_for_auth(self, headers, querys, auth_settings, :param headers: Header parameters dict to be updated. :param querys: Query parameters tuple list to be updated. :param auth_settings: Authentication setting identifiers list. - :resource_path: A string representation of the HTTP request resource path. - :method: A string representation of the HTTP request method. - :body: A object representing the body of the HTTP request. + :param resource_path: A string representation of the HTTP request resource path. + :param method: A string representation of the HTTP request method. + :param body: A object representing the body of the HTTP request. The object type is the return value of sanitize_for_serialization(). """ if not auth_settings: diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/another_fake_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/another_fake_api.py index c92e1b4a2099..9421b337d4bf 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/another_fake_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/another_fake_api.py @@ -42,21 +42,26 @@ def call_123_test_special_tags(self, client, **kwargs): # noqa: E501 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 @@ def call_123_test_special_tags_with_http_info(self, client, **kwargs): # noqa: 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() diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/default_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/default_api.py index e1a71f14293e..a14b43c994ce 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/default_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/default_api.py @@ -41,20 +41,24 @@ def foo_get(self, **kwargs): # noqa: E501 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 @@ def foo_get_with_http_info(self, **kwargs): # noqa: E501 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() diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/fake_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/fake_api.py index 01f431fb4303..49c9033aca20 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/fake_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/fake_api.py @@ -41,20 +41,24 @@ def fake_health_get(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_health_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: HealthCheckResult + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: HealthCheckResult """ kwargs['_return_http_data_only'] = True return self.fake_health_get_with_http_info(**kwargs) # noqa: E501 @@ -64,22 +68,27 @@ def fake_health_get_with_http_info(self, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_health_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(HealthCheckResult, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(HealthCheckResult, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -144,23 +153,30 @@ def fake_http_signature_test(self, pet, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_http_signature_test(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 str query_1: query parameter - :param str header_1: header parameter + :param pet: Pet object that needs to be added to the store (required) + :type pet: Pet + :param query_1: query parameter + :type query_1: str + :param header_1: header parameter + :type header_1: 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.fake_http_signature_test_with_http_info(pet, **kwargs) # noqa: E501 @@ -170,25 +186,33 @@ def fake_http_signature_test_with_http_info(self, pet, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_http_signature_test_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 str query_1: query parameter - :param str header_1: header parameter + :param pet: Pet object that needs to be added to the store (required) + :type pet: Pet + :param query_1: query parameter + :type query_1: str + :param header_1: header parameter + :type header_1: str + :param async_req: Whether to execute the request asynchronously. + :type async_req: bool, optional :param _return_http_data_only: response data without head status code and headers + :type _return_http_data_only: bool, optional :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without reading/decoding response data. Default is True. + :type _preload_content: bool, optional :param _request_timeout: timeout setting for this request. If one number provided, it will be total request timeout. It can also be a pair (tuple) of (connection, read) timeouts. - :return: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -267,21 +291,26 @@ def fake_outer_boolean_serialize(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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: bool + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: bool """ kwargs['_return_http_data_only'] = True return self.fake_outer_boolean_serialize_with_http_info(**kwargs) # noqa: E501 @@ -292,23 +321,29 @@ def fake_outer_boolean_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer boolean types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_boolean_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param bool body: Input boolean as post body + :param body: Input boolean as post body + :type body: bool + :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(bool, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(bool, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -381,21 +416,26 @@ def fake_outer_composite_serialize(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite outer_composite: Input composite as post body + :param outer_composite: Input composite as post body + :type outer_composite: OuterComposite + :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: OuterComposite + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: OuterComposite """ kwargs['_return_http_data_only'] = True return self.fake_outer_composite_serialize_with_http_info(**kwargs) # noqa: E501 @@ -406,23 +446,29 @@ def fake_outer_composite_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of object with outer number type # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_composite_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param OuterComposite outer_composite: Input composite as post body + :param outer_composite: Input composite as post body + :type outer_composite: OuterComposite + :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(OuterComposite, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(OuterComposite, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -495,21 +541,26 @@ def fake_outer_number_serialize(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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: float + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: float """ kwargs['_return_http_data_only'] = True return self.fake_outer_number_serialize_with_http_info(**kwargs) # noqa: E501 @@ -520,23 +571,29 @@ def fake_outer_number_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer number types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_number_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float body: Input number as post body + :param body: Input number as post body + :type body: float + :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(float, status_code(int), headers(HTTPHeaderDict)) + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: tuple(float, status_code(int), headers(HTTPHeaderDict)) """ local_var_params = locals() @@ -609,21 +666,26 @@ def fake_outer_string_serialize(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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.fake_outer_string_serialize_with_http_info(**kwargs) # noqa: E501 @@ -634,23 +696,29 @@ def fake_outer_string_serialize_with_http_info(self, **kwargs): # noqa: E501 Test serialization of outer string types # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.fake_outer_string_serialize_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str body: Input string as post body + :param body: Input string as post body + :type body: 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() @@ -723,21 +791,26 @@ def test_body_with_file_schema(self, file_schema_test_class, **kwargs): # noqa: For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema(file_schema_test_class, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass file_schema_test_class: (required) + :param file_schema_test_class: (required) + :type file_schema_test_class: FileSchemaTestClass + :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.test_body_with_file_schema_with_http_info(file_schema_test_class, **kwargs) # noqa: E501 @@ -748,23 +821,29 @@ def test_body_with_file_schema_with_http_info(self, file_schema_test_class, **kw For this test, the body for this request much reference a schema named `File`. # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_file_schema_with_http_info(file_schema_test_class, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param FileSchemaTestClass file_schema_test_class: (required) + :param file_schema_test_class: (required) + :type file_schema_test_class: FileSchemaTestClass + :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() @@ -836,22 +915,28 @@ def test_body_with_query_params(self, query, user, **kwargs): # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params(query, user, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User user: (required) + :param query: (required) + :type query: str + :param user: (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.test_body_with_query_params_with_http_info(query, user, **kwargs) # noqa: E501 @@ -861,24 +946,31 @@ def test_body_with_query_params_with_http_info(self, query, user, **kwargs): # This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_body_with_query_params_with_http_info(query, user, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str query: (required) - :param User user: (required) + :param query: (required) + :type query: str + :param user: (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() @@ -958,21 +1050,26 @@ def test_client_model(self, client, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model(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_client_model_with_http_info(client, **kwargs) # noqa: E501 @@ -983,23 +1080,29 @@ def test_client_model_with_http_info(self, client, **kwargs): # noqa: E501 To test \"client\" model # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_client_model_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() @@ -1076,34 +1179,52 @@ def test_endpoint_parameters(self, number, double, pattern_without_delimiter, by Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, **kwargs) # noqa: E501 @@ -1114,36 +1235,55 @@ def test_endpoint_parameters_with_http_info(self, number, double, pattern_withou Fake endpoint for testing various parameters 假端點 偽のエンドポイント 가짜 엔드 포인트 # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_endpoint_parameters_with_http_info(number, double, pattern_without_delimiter, byte, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param float number: None (required) - :param float double: None (required) - :param str pattern_without_delimiter: None (required) - :param str byte: None (required) - :param int integer: None - :param int int32: None - :param int int64: None - :param float float: None - :param str string: None - :param file binary: None - :param date date: None - :param datetime date_time: None - :param str password: None - :param str param_callback: None + :param number: None (required) + :type number: float + :param double: None (required) + :type double: float + :param pattern_without_delimiter: None (required) + :type pattern_without_delimiter: str + :param byte: None (required) + :type byte: str + :param integer: None + :type integer: int + :param int32: None + :type int32: int + :param int64: None + :type int64: int + :param float: None + :type float: float + :param string: None + :type string: str + :param binary: None + :type binary: file + :param date: None + :type date: date + :param date_time: None + :type date_time: datetime + :param password: None + :type password: str + :param param_callback: None + :type param_callback: 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() @@ -1295,28 +1435,40 @@ def test_enum_parameters(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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.test_enum_parameters_with_http_info(**kwargs) # noqa: E501 @@ -1327,30 +1479,43 @@ def test_enum_parameters_with_http_info(self, **kwargs): # noqa: E501 To test enum parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_enum_parameters_with_http_info(async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] enum_header_string_array: Header parameter enum test (string array) - :param str enum_header_string: Header parameter enum test (string) - :param list[str] enum_query_string_array: Query parameter enum test (string array) - :param str enum_query_string: Query parameter enum test (string) - :param int enum_query_integer: Query parameter enum test (double) - :param float enum_query_double: Query parameter enum test (double) - :param list[str] enum_form_string_array: Form parameter enum test (string array) - :param str enum_form_string: Form parameter enum test (string) + :param enum_header_string_array: Header parameter enum test (string array) + :type enum_header_string_array: list[str] + :param enum_header_string: Header parameter enum test (string) + :type enum_header_string: str + :param enum_query_string_array: Query parameter enum test (string array) + :type enum_query_string_array: list[str] + :param enum_query_string: Query parameter enum test (string) + :type enum_query_string: str + :param enum_query_integer: Query parameter enum test (double) + :type enum_query_integer: int + :param enum_query_double: Query parameter enum test (double) + :type enum_query_double: float + :param enum_form_string_array: Form parameter enum test (string array) + :type enum_form_string_array: list[str] + :param enum_form_string: Form parameter enum test (string) + :type enum_form_string: 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() @@ -1443,26 +1608,36 @@ def test_group_parameters(self, required_string_group, required_boolean_group, r Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: 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.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, **kwargs) # noqa: E501 @@ -1473,28 +1648,39 @@ def test_group_parameters_with_http_info(self, required_string_group, required_b Fake endpoint to test group parameters (optional) # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_group_parameters_with_http_info(required_string_group, required_boolean_group, required_int64_group, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param int required_string_group: Required String in group parameters (required) - :param bool required_boolean_group: Required Boolean in group parameters (required) - :param int required_int64_group: Required Integer in group parameters (required) - :param int string_group: String in group parameters - :param bool boolean_group: Boolean in group parameters - :param int int64_group: Integer in group parameters + :param required_string_group: Required String in group parameters (required) + :type required_string_group: int + :param required_boolean_group: Required Boolean in group parameters (required) + :type required_boolean_group: bool + :param required_int64_group: Required Integer in group parameters (required) + :type required_int64_group: int + :param string_group: String in group parameters + :type string_group: int + :param boolean_group: Boolean in group parameters + :type boolean_group: bool + :param int64_group: Integer in group parameters + :type int64_group: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() @@ -1585,21 +1771,26 @@ def test_inline_additional_properties(self, request_body, **kwargs): # noqa: E5 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties(request_body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) request_body: request body (required) + :param request_body: request body (required) + :type request_body: dict(str, 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.test_inline_additional_properties_with_http_info(request_body, **kwargs) # noqa: E501 @@ -1609,23 +1800,29 @@ def test_inline_additional_properties_with_http_info(self, request_body, **kwarg This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_inline_additional_properties_with_http_info(request_body, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param dict(str, str) request_body: request body (required) + :param request_body: request body (required) + :type request_body: dict(str, 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() @@ -1697,22 +1894,28 @@ def test_json_form_data(self, param, param2, **kwargs): # 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_json_form_data(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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.test_json_form_data_with_http_info(param, param2, **kwargs) # noqa: E501 @@ -1722,24 +1925,31 @@ def test_json_form_data_with_http_info(self, param, param2, **kwargs): # noqa: This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_json_form_data_with_http_info(param, param2, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param str param: field1 (required) - :param str param2: field2 (required) + :param param: field1 (required) + :type param: str + :param param2: field2 (required) + :type param2: 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() @@ -1819,25 +2029,34 @@ def test_query_parameter_collection_format(self, pipe, ioutil, http, url, contex To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: 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.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, **kwargs) # noqa: E501 @@ -1848,27 +2067,37 @@ def test_query_parameter_collection_format_with_http_info(self, pipe, ioutil, ht To test the collection format in query parameters # noqa: E501 This method makes a synchronous HTTP request by default. To make an asynchronous HTTP request, please pass async_req=True + >>> thread = api.test_query_parameter_collection_format_with_http_info(pipe, ioutil, http, url, context, async_req=True) >>> result = thread.get() - :param async_req bool: execute request asynchronously - :param list[str] pipe: (required) - :param list[str] ioutil: (required) - :param list[str] http: (required) - :param list[str] url: (required) - :param list[str] context: (required) + :param pipe: (required) + :type pipe: list[str] + :param ioutil: (required) + :type ioutil: list[str] + :param http: (required) + :type http: list[str] + :param url: (required) + :type url: list[str] + :param context: (required) + :type context: 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: None + :return: Returns the result object. If the method is called asynchronously, returns the request thread. + :rtype: None """ local_var_params = locals() diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py index 0fd2b6274cab..19d22cd10d65 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/fake_classname_tags_123_api.py @@ -42,21 +42,26 @@ def test_classname(self, client, **kwargs): # noqa: E501 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 @@ def test_classname_with_http_info(self, client, **kwargs): # noqa: E501 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() diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/pet_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/pet_api.py index bf25e077aec5..8c8f5d936719 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/pet_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/pet_api.py @@ -41,21 +41,26 @@ def add_pet(self, pet, **kwargs): # noqa: E501 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 @@ def add_pet_with_http_info(self, pet, **kwargs): # noqa: E501 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 @@ def delete_pet(self, pet_id, **kwargs): # 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_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 @@ def delete_pet_with_http_info(self, pet_id, **kwargs): # 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_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 @@ def find_pets_by_status(self, status, **kwargs): # noqa: E501 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 @@ def find_pets_by_status_with_http_info(self, status, **kwargs): # noqa: E501 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 @@ def find_pets_by_tags(self, tags, **kwargs): # noqa: E501 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 @@ def find_pets_by_tags_with_http_info(self, tags, **kwargs): # noqa: E501 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 @@ def get_pet_by_id(self, pet_id, **kwargs): # noqa: E501 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 @@ def get_pet_by_id_with_http_info(self, pet_id, **kwargs): # noqa: E501 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 @@ def update_pet(self, pet, **kwargs): # 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_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 @@ def update_pet_with_http_info(self, pet, **kwargs): # 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_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 @@ def update_pet_with_form(self, pet_id, **kwargs): # 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_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 @@ def update_pet_with_form_with_http_info(self, pet_id, **kwargs): # 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_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 @@ def upload_file(self, pet_id, **kwargs): # noqa: E501 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 @@ def upload_file_with_http_info(self, pet_id, **kwargs): # noqa: E501 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 @@ def upload_file_with_required_file(self, pet_id, required_file, **kwargs): # no 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 @@ def upload_file_with_required_file_with_http_info(self, pet_id, required_file, * 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() diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/store_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/store_api.py index a5d1ddc0d3de..2b35556ba815 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/store_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/store_api.py @@ -42,21 +42,26 @@ def delete_order(self, order_id, **kwargs): # noqa: E501 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 @@ def delete_order_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def get_inventory(self, **kwargs): # noqa: E501 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 @@ def get_inventory_with_http_info(self, **kwargs): # noqa: E501 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 @@ def get_order_by_id(self, order_id, **kwargs): # noqa: E501 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 @@ def get_order_by_id_with_http_info(self, order_id, **kwargs): # noqa: E501 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 @@ def place_order(self, order, **kwargs): # noqa: E501 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 @@ def place_order_with_http_info(self, order, **kwargs): # noqa: E501 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() diff --git a/samples/openapi3/client/petstore/python/petstore_api/api/user_api.py b/samples/openapi3/client/petstore/python/petstore_api/api/user_api.py index c1357adf9997..38d0b4ee5b9f 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/api/user_api.py +++ b/samples/openapi3/client/petstore/python/petstore_api/api/user_api.py @@ -42,21 +42,26 @@ def create_user(self, user, **kwargs): # noqa: E501 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 @@ def create_user_with_http_info(self, user, **kwargs): # noqa: E501 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 @@ def create_users_with_array_input(self, user, **kwargs): # 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_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 @@ def create_users_with_array_input_with_http_info(self, user, **kwargs): # noqa: 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 @@ def create_users_with_list_input(self, user, **kwargs): # 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_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 @@ def create_users_with_list_input_with_http_info(self, user, **kwargs): # noqa: 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 @@ def delete_user(self, username, **kwargs): # noqa: E501 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 @@ def delete_user_with_http_info(self, username, **kwargs): # noqa: E501 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 @@ def get_user_by_name(self, username, **kwargs): # 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_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 @@ def get_user_by_name_with_http_info(self, username, **kwargs): # 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_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 @@ def login_user(self, username, password, **kwargs): # noqa: E501 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 @@ def login_user_with_http_info(self, username, password, **kwargs): # noqa: E501 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 @@ def logout_user(self, **kwargs): # noqa: E501 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 @@ def logout_user_with_http_info(self, **kwargs): # noqa: E501 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 @@ def update_user(self, username, user, **kwargs): # noqa: E501 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 @@ def update_user_with_http_info(self, username, user, **kwargs): # noqa: E501 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() diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/additional_properties_class.py b/samples/openapi3/client/petstore/python/petstore_api/models/additional_properties_class.py index 9da151ae8294..2e5d49aa2562 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/additional_properties_class.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/additional_properties_class.py @@ -73,7 +73,7 @@ def map_property(self, map_property): :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 @@ def map_of_map_property(self, map_of_map_property): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/animal.py b/samples/openapi3/client/petstore/python/petstore_api/models/animal.py index 65cef1a60885..4c233ad4a886 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/animal.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/animal.py @@ -77,7 +77,7 @@ def class_name(self, class_name): :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 @@ def color(self, color): :param color: The color of this Animal. # noqa: E501 - :type: str + :type color: str """ self._color = color diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/api_response.py b/samples/openapi3/client/petstore/python/petstore_api/models/api_response.py index 24e80d02aea4..8cb64673c354 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/api_response.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/api_response.py @@ -78,7 +78,7 @@ def code(self, code): :param code: The code of this ApiResponse. # noqa: E501 - :type: int + :type code: int """ self._code = code @@ -99,7 +99,7 @@ def type(self, type): :param type: The type of this ApiResponse. # noqa: E501 - :type: str + :type type: str """ self._type = type @@ -120,7 +120,7 @@ def message(self, message): :param message: The message of this ApiResponse. # noqa: E501 - :type: str + :type message: str """ self._message = message diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py b/samples/openapi3/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py index 1f654452077f..41a689c534ac 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/array_of_array_of_number_only.py @@ -68,7 +68,7 @@ def array_array_number(self, array_array_number): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/array_of_number_only.py b/samples/openapi3/client/petstore/python/petstore_api/models/array_of_number_only.py index 27ba1f58e31e..ddb7f7c7abe0 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/array_of_number_only.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/array_of_number_only.py @@ -68,7 +68,7 @@ def array_number(self, array_number): :param array_number: The array_number of this ArrayOfNumberOnly. # noqa: E501 - :type: list[float] + :type array_number: list[float] """ self._array_number = array_number diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/array_test.py b/samples/openapi3/client/petstore/python/petstore_api/models/array_test.py index f34a372f6f3b..e8e5c378f98e 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/array_test.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/array_test.py @@ -78,7 +78,7 @@ def array_of_string(self, array_of_string): :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 @@ def array_array_of_integer(self, array_array_of_integer): :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 @@ def array_array_of_model(self, array_array_of_model): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/capitalization.py b/samples/openapi3/client/petstore/python/petstore_api/models/capitalization.py index cef34c5f6dc3..967d324a0ab0 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/capitalization.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/capitalization.py @@ -93,7 +93,7 @@ def small_camel(self, small_camel): :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 @@ def capital_camel(self, capital_camel): :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 @@ def small_snake(self, small_snake): :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 @@ def capital_snake(self, capital_snake): :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 @@ def sca_eth_flow_points(self, sca_eth_flow_points): :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 @@ def att_name(self, att_name): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/cat.py b/samples/openapi3/client/petstore/python/petstore_api/models/cat.py index e39c1c82508c..b3b0d868c7f0 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/cat.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/cat.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this Cat. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/cat_all_of.py b/samples/openapi3/client/petstore/python/petstore_api/models/cat_all_of.py index 7e90fab93489..f573a04636c1 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/cat_all_of.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/cat_all_of.py @@ -68,7 +68,7 @@ def declawed(self, declawed): :param declawed: The declawed of this CatAllOf. # noqa: E501 - :type: bool + :type declawed: bool """ self._declawed = declawed diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/category.py b/samples/openapi3/client/petstore/python/petstore_api/models/category.py index b47c148953ea..11a7bf85f3ad 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/category.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/category.py @@ -72,7 +72,7 @@ def id(self, id): :param id: The id of this Category. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -93,7 +93,7 @@ def name(self, name): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/class_model.py b/samples/openapi3/client/petstore/python/petstore_api/models/class_model.py index ef6060ffa70d..aac505ea064d 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/class_model.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/class_model.py @@ -68,7 +68,7 @@ def _class(self, _class): :param _class: The _class of this ClassModel. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/client.py b/samples/openapi3/client/petstore/python/petstore_api/models/client.py index ee5dbf1c43a1..2006350b2109 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/client.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/client.py @@ -68,7 +68,7 @@ def client(self, client): :param client: The client of this Client. # noqa: E501 - :type: str + :type client: str """ self._client = client diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/dog.py b/samples/openapi3/client/petstore/python/petstore_api/models/dog.py index eacb63eedb09..fb9024d0bb76 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/dog.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/dog.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this Dog. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/dog_all_of.py b/samples/openapi3/client/petstore/python/petstore_api/models/dog_all_of.py index 48e048557085..5943ba900dd6 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/dog_all_of.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/dog_all_of.py @@ -68,7 +68,7 @@ def breed(self, breed): :param breed: The breed of this DogAllOf. # noqa: E501 - :type: str + :type breed: str """ self._breed = breed diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/enum_arrays.py b/samples/openapi3/client/petstore/python/petstore_api/models/enum_arrays.py index 819ff322157d..ae2ea1d42511 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/enum_arrays.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/enum_arrays.py @@ -73,7 +73,7 @@ def just_symbol(self, just_symbol): :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 @@ def array_enum(self, array_enum): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/enum_test.py b/samples/openapi3/client/petstore/python/petstore_api/models/enum_test.py index 24ed1b462d0d..8af01fd85cc1 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/enum_test.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/enum_test.py @@ -101,7 +101,7 @@ def enum_string(self, enum_string): :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 @@ def enum_string_required(self, enum_string_required): :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 @@ def enum_integer(self, enum_integer): :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 @@ def enum_number(self, enum_number): :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 @@ def outer_enum(self, outer_enum): :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 @@ def outer_enum_integer(self, outer_enum_integer): :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 @@ def outer_enum_default_value(self, outer_enum_default_value): :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 @@ def outer_enum_integer_default_value(self, outer_enum_integer_default_value): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/file.py b/samples/openapi3/client/petstore/python/petstore_api/models/file.py index 282df2957e67..4fb5c31762e8 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/file.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/file.py @@ -70,7 +70,7 @@ def source_uri(self, source_uri): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/file_schema_test_class.py b/samples/openapi3/client/petstore/python/petstore_api/models/file_schema_test_class.py index de7f865b47e2..2f2d44a7b33d 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/file_schema_test_class.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/file_schema_test_class.py @@ -73,7 +73,7 @@ def file(self, file): :param file: The file of this FileSchemaTestClass. # noqa: E501 - :type: File + :type file: File """ self._file = file @@ -94,7 +94,7 @@ def files(self, files): :param files: The files of this FileSchemaTestClass. # noqa: E501 - :type: list[File] + :type files: list[File] """ self._files = files diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/foo.py b/samples/openapi3/client/petstore/python/petstore_api/models/foo.py index 0a98b8837cac..f06272faa709 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/foo.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/foo.py @@ -68,7 +68,7 @@ def bar(self, bar): :param bar: The bar of this Foo. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/format_test.py b/samples/openapi3/client/petstore/python/petstore_api/models/format_test.py index 60e64039be55..f6d90fb0d588 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/format_test.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/format_test.py @@ -134,7 +134,7 @@ def integer(self, integer): :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 @@ def int32(self, int32): :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 @@ def int64(self, int64): :param int64: The int64 of this FormatTest. # noqa: E501 - :type: int + :type int64: int """ self._int64 = int64 @@ -209,7 +209,7 @@ def number(self, number): :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 @@ def float(self, float): :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 @@ def double(self, double): :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 @@ def string(self, string): :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 @@ def byte(self, byte): :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 @@ def binary(self, binary): :param binary: The binary of this FormatTest. # noqa: E501 - :type: file + :type binary: file """ self._binary = binary @@ -360,7 +360,7 @@ def date(self, date): :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 @@ def date_time(self, date_time): :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 @@ def uuid(self, uuid): :param uuid: The uuid of this FormatTest. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -425,7 +425,7 @@ def password(self, password): :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 @@ def pattern_with_digits(self, pattern_with_digits): 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 @@ def pattern_with_digits_and_delimiter(self, pattern_with_digits_and_delimiter): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/has_only_read_only.py b/samples/openapi3/client/petstore/python/petstore_api/models/has_only_read_only.py index 5fc2f8a9ebdd..fa496519ecb2 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/has_only_read_only.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/has_only_read_only.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def foo(self, foo): :param foo: The foo of this HasOnlyReadOnly. # noqa: E501 - :type: str + :type foo: str """ self._foo = foo diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/health_check_result.py b/samples/openapi3/client/petstore/python/petstore_api/models/health_check_result.py index 7c62a43ef7a2..2c429088a49d 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/health_check_result.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/health_check_result.py @@ -67,7 +67,7 @@ def nullable_message(self, nullable_message): :param nullable_message: The nullable_message of this HealthCheckResult. # noqa: E501 - :type: str + :type nullable_message: str """ self._nullable_message = nullable_message diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object.py index 0ac70b16a32a..ecd4978ff4fd 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object.py @@ -75,7 +75,7 @@ def name(self, name): 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 @@ def status(self, status): Updated status of the pet # noqa: E501 :param status: The status of this InlineObject. # noqa: E501 - :type: str + :type status: str """ self._status = status diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object1.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object1.py index 300af445d033..0e5ebe6b9efb 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object1.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object1.py @@ -75,7 +75,7 @@ def additional_metadata(self, additional_metadata): 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 @@ def file(self, file): file to upload # noqa: E501 :param file: The file of this InlineObject1. # noqa: E501 - :type: file + :type file: file """ self._file = file diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object2.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object2.py index f904d0a24d5d..92c5ed5d908c 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object2.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object2.py @@ -75,7 +75,7 @@ def enum_form_string_array(self, enum_form_string_array): 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 @@ def enum_form_string(self, enum_form_string): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object3.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object3.py index 9870a922b2b7..5c38b7480314 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object3.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object3.py @@ -131,7 +131,7 @@ def integer(self, integer): 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 @@ def int32(self, int32): 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 @@ def int64(self, int64): None # noqa: E501 :param int64: The int64 of this InlineObject3. # noqa: E501 - :type: int + :type int64: int """ self._int64 = int64 @@ -212,7 +212,7 @@ def number(self, number): 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 @@ def float(self, float): 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 @@ def double(self, double): 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 @@ def string(self, string): 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 @@ def pattern_without_delimiter(self, pattern_without_delimiter): 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 @@ def byte(self, byte): 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 @@ def binary(self, binary): None # noqa: E501 :param binary: The binary of this InlineObject3. # noqa: E501 - :type: file + :type binary: file """ self._binary = binary @@ -402,7 +402,7 @@ def date(self, date): None # noqa: E501 :param date: The date of this InlineObject3. # noqa: E501 - :type: date + :type date: date """ self._date = date @@ -425,7 +425,7 @@ def date_time(self, date_time): 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 @@ def password(self, password): 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 @@ def callback(self, callback): None # noqa: E501 :param callback: The callback of this InlineObject3. # noqa: E501 - :type: str + :type callback: str """ self._callback = callback diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object4.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object4.py index a4ecb978d0aa..1492d942a647 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object4.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object4.py @@ -73,7 +73,7 @@ def param(self, param): 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 @@ def param2(self, param2): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object5.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object5.py index 2badeb2274cf..d8ed83d96802 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_object5.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_object5.py @@ -74,7 +74,7 @@ def additional_metadata(self, additional_metadata): 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 @@ def required_file(self, required_file): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/inline_response_default.py b/samples/openapi3/client/petstore/python/petstore_api/models/inline_response_default.py index 3904d39c9ccf..249eb98d3c26 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/inline_response_default.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/inline_response_default.py @@ -68,7 +68,7 @@ def string(self, string): :param string: The string of this InlineResponseDefault. # noqa: E501 - :type: Foo + :type string: Foo """ self._string = string diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/list.py b/samples/openapi3/client/petstore/python/petstore_api/models/list.py index d58d13e90fbc..e21a220f71cd 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/list.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/list.py @@ -68,7 +68,7 @@ def _123_list(self, _123_list): :param _123_list: The _123_list of this List. # noqa: E501 - :type: str + :type _123_list: str """ self.__123_list = _123_list diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/map_test.py b/samples/openapi3/client/petstore/python/petstore_api/models/map_test.py index f0cfba5073b0..8afc875ce517 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/map_test.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/map_test.py @@ -83,7 +83,7 @@ def map_map_of_string(self, map_map_of_string): :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 @@ def map_of_enum_string(self, map_of_enum_string): :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 @@ def direct_map(self, direct_map): :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 @@ def indirect_map(self, indirect_map): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py b/samples/openapi3/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py index 5da34f8830e8..8aecbf0f558a 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/mixed_properties_and_additional_properties_class.py @@ -78,7 +78,7 @@ def uuid(self, uuid): :param uuid: The uuid of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: str + :type uuid: str """ self._uuid = uuid @@ -99,7 +99,7 @@ def date_time(self, date_time): :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 @@ def map(self, map): :param map: The map of this MixedPropertiesAndAdditionalPropertiesClass. # noqa: E501 - :type: dict(str, Animal) + :type map: dict(str, Animal) """ self._map = map diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/model200_response.py b/samples/openapi3/client/petstore/python/petstore_api/models/model200_response.py index 841ce1f18f3d..3f4c4e2bd2a7 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/model200_response.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/model200_response.py @@ -73,7 +73,7 @@ def name(self, name): :param name: The name of this Model200Response. # noqa: E501 - :type: int + :type name: int """ self._name = name @@ -94,7 +94,7 @@ def _class(self, _class): :param _class: The _class of this Model200Response. # noqa: E501 - :type: str + :type _class: str """ self.__class = _class diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/model_return.py b/samples/openapi3/client/petstore/python/petstore_api/models/model_return.py index fdd8d72314ad..1009c50ef08e 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/model_return.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/model_return.py @@ -68,7 +68,7 @@ def _return(self, _return): :param _return: The _return of this ModelReturn. # noqa: E501 - :type: int + :type _return: int """ self.__return = _return diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/name.py b/samples/openapi3/client/petstore/python/petstore_api/models/name.py index bb2c1fbd73cc..6ee8261e7821 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/name.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/name.py @@ -82,7 +82,7 @@ def name(self, name): :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 @@ def snake_case(self, snake_case): :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 @@ def _property(self, _property): :param _property: The _property of this Name. # noqa: E501 - :type: str + :type _property: str """ self.__property = _property @@ -147,7 +147,7 @@ def _123_number(self, _123_number): :param _123_number: The _123_number of this Name. # noqa: E501 - :type: int + :type _123_number: int """ self.__123_number = _123_number diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/nullable_class.py b/samples/openapi3/client/petstore/python/petstore_api/models/nullable_class.py index b81eb554e916..e0a26244a48f 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/nullable_class.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/nullable_class.py @@ -113,7 +113,7 @@ def integer_prop(self, integer_prop): :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 @@ def number_prop(self, number_prop): :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 @@ def boolean_prop(self, boolean_prop): :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 @@ def string_prop(self, string_prop): :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 @@ def date_prop(self, date_prop): :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 @@ def datetime_prop(self, datetime_prop): :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 @@ def array_nullable_prop(self, array_nullable_prop): :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 @@ def array_and_items_nullable_prop(self, array_and_items_nullable_prop): :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 @@ def array_items_nullable(self, array_items_nullable): :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 @@ def object_nullable_prop(self, object_nullable_prop): :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 @@ def object_and_items_nullable_prop(self, object_and_items_nullable_prop): :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 @@ def object_items_nullable(self, object_items_nullable): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/number_only.py b/samples/openapi3/client/petstore/python/petstore_api/models/number_only.py index 99b2424852fb..90f09d8b7d56 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/number_only.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/number_only.py @@ -68,7 +68,7 @@ def just_number(self, just_number): :param just_number: The just_number of this NumberOnly. # noqa: E501 - :type: float + :type just_number: float """ self._just_number = just_number diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/order.py b/samples/openapi3/client/petstore/python/petstore_api/models/order.py index 8c863cce8fe5..8f298aa3d9c2 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/order.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/order.py @@ -93,7 +93,7 @@ def id(self, id): :param id: The id of this Order. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -114,7 +114,7 @@ def pet_id(self, pet_id): :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 @@ def quantity(self, quantity): :param quantity: The quantity of this Order. # noqa: E501 - :type: int + :type quantity: int """ self._quantity = quantity @@ -156,7 +156,7 @@ def ship_date(self, ship_date): :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 @@ def status(self, status): 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 @@ def complete(self, complete): :param complete: The complete of this Order. # noqa: E501 - :type: bool + :type complete: bool """ self._complete = complete diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/outer_composite.py b/samples/openapi3/client/petstore/python/petstore_api/models/outer_composite.py index c11859114a57..85fe36c7ef07 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/outer_composite.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/outer_composite.py @@ -78,7 +78,7 @@ def my_number(self, my_number): :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 @@ def my_string(self, my_string): :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 @@ def my_boolean(self, my_boolean): :param my_boolean: The my_boolean of this OuterComposite. # noqa: E501 - :type: bool + :type my_boolean: bool """ self._my_boolean = my_boolean diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/pet.py b/samples/openapi3/client/petstore/python/petstore_api/models/pet.py index edbf73f53127..b948a6436db1 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/pet.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/pet.py @@ -91,7 +91,7 @@ def id(self, id): :param id: The id of this Pet. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -112,7 +112,7 @@ def category(self, category): :param category: The category of this Pet. # noqa: E501 - :type: Category + :type category: Category """ self._category = category @@ -133,7 +133,7 @@ def name(self, name): :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 @@ def photo_urls(self, photo_urls): :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 @@ def tags(self, tags): :param tags: The tags of this Pet. # noqa: E501 - :type: list[Tag] + :type tags: list[Tag] """ self._tags = tags @@ -202,7 +202,7 @@ def status(self, status): 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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/read_only_first.py b/samples/openapi3/client/petstore/python/petstore_api/models/read_only_first.py index a84679e98dee..3a305087dc26 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/read_only_first.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/read_only_first.py @@ -73,7 +73,7 @@ def bar(self, bar): :param bar: The bar of this ReadOnlyFirst. # noqa: E501 - :type: str + :type bar: str """ self._bar = bar @@ -94,7 +94,7 @@ def baz(self, baz): :param baz: The baz of this ReadOnlyFirst. # noqa: E501 - :type: str + :type baz: str """ self._baz = baz diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/special_model_name.py b/samples/openapi3/client/petstore/python/petstore_api/models/special_model_name.py index 396e75bcee5c..d2535eb65aca 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/special_model_name.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/special_model_name.py @@ -68,7 +68,7 @@ def special_property_name(self, special_property_name): :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 diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/tag.py b/samples/openapi3/client/petstore/python/petstore_api/models/tag.py index d6137fdd47f0..7492d30d9eb6 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/tag.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/tag.py @@ -73,7 +73,7 @@ def id(self, id): :param id: The id of this Tag. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -94,7 +94,7 @@ def name(self, name): :param name: The name of this Tag. # noqa: E501 - :type: str + :type name: str """ self._name = name diff --git a/samples/openapi3/client/petstore/python/petstore_api/models/user.py b/samples/openapi3/client/petstore/python/petstore_api/models/user.py index de88bda4cde7..0e25f9f17104 100644 --- a/samples/openapi3/client/petstore/python/petstore_api/models/user.py +++ b/samples/openapi3/client/petstore/python/petstore_api/models/user.py @@ -103,7 +103,7 @@ def id(self, id): :param id: The id of this User. # noqa: E501 - :type: int + :type id: int """ self._id = id @@ -124,7 +124,7 @@ def username(self, username): :param username: The username of this User. # noqa: E501 - :type: str + :type username: str """ self._username = username @@ -145,7 +145,7 @@ def first_name(self, first_name): :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 @@ def last_name(self, last_name): :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 @@ def email(self, email): :param email: The email of this User. # noqa: E501 - :type: str + :type email: str """ self._email = email @@ -208,7 +208,7 @@ def password(self, password): :param password: The password of this User. # noqa: E501 - :type: str + :type password: str """ self._password = password @@ -229,7 +229,7 @@ def phone(self, phone): :param phone: The phone of this User. # noqa: E501 - :type: str + :type phone: str """ self._phone = phone @@ -252,7 +252,7 @@ def user_status(self, user_status): 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 diff --git a/samples/openapi3/server/petstore/python-flask-python2/.openapi-generator/VERSION b/samples/openapi3/server/petstore/python-flask-python2/.openapi-generator/VERSION index bfbf77eb7fad..d99e7162d01f 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/.openapi-generator/VERSION +++ b/samples/openapi3/server/petstore/python-flask-python2/.openapi-generator/VERSION @@ -1 +1 @@ -4.3.0-SNAPSHOT \ No newline at end of file +5.0.0-SNAPSHOT \ No newline at end of file diff --git a/samples/openapi3/server/petstore/python-flask-python2/openapi_server/controllers/pet_controller.py b/samples/openapi3/server/petstore/python-flask-python2/openapi_server/controllers/pet_controller.py index 20b15fabbd98..5ae8f380ee38 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/openapi_server/controllers/pet_controller.py +++ b/samples/openapi3/server/petstore/python-flask-python2/openapi_server/controllers/pet_controller.py @@ -17,7 +17,7 @@ def add_pet(pet): # noqa: E501 :param pet: Pet object that needs to be added to the store :type pet: dict | bytes - :rtype: Pet + :rtype: None """ if connexion.request.is_json: pet = Pet.from_dict(connexion.request.get_json()) # noqa: E501 @@ -86,7 +86,7 @@ def update_pet(pet): # noqa: E501 :param pet: Pet object that needs to be added to the store :type pet: dict | bytes - :rtype: Pet + :rtype: None """ if connexion.request.is_json: pet = Pet.from_dict(connexion.request.get_json()) # noqa: E501 diff --git a/samples/openapi3/server/petstore/python-flask-python2/openapi_server/openapi/openapi.yaml b/samples/openapi3/server/petstore/python-flask-python2/openapi_server/openapi/openapi.yaml index 142289318ae3..31100fda5278 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/openapi_server/openapi/openapi.yaml +++ b/samples/openapi3/server/petstore/python-flask-python2/openapi_server/openapi/openapi.yaml @@ -26,15 +26,6 @@ paths: requestBody: $ref: '#/components/requestBodies/Pet' responses: - "200": - content: - application/xml: - schema: - $ref: '#/components/schemas/Pet' - application/json: - schema: - $ref: '#/components/schemas/Pet' - description: successful operation "405": description: Invalid input security: @@ -50,15 +41,6 @@ paths: requestBody: $ref: '#/components/requestBodies/Pet' responses: - "200": - content: - application/xml: - schema: - $ref: '#/components/schemas/Pet' - application/json: - schema: - $ref: '#/components/schemas/Pet' - description: successful operation "400": description: Invalid ID supplied "404": diff --git a/samples/openapi3/server/petstore/python-flask-python2/openapi_server/test/test_pet_controller.py b/samples/openapi3/server/petstore/python-flask-python2/openapi_server/test/test_pet_controller.py index dc0a8e2deb0b..6c031e9f4b10 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/openapi_server/test/test_pet_controller.py +++ b/samples/openapi3/server/petstore/python-flask-python2/openapi_server/test/test_pet_controller.py @@ -41,7 +41,6 @@ def test_add_pet(self): "status" : "available" } headers = { - 'Accept': 'application/json', 'Content-Type': 'application/json', 'Authorization': 'Bearer special-key', } @@ -146,7 +145,6 @@ def test_update_pet(self): "status" : "available" } headers = { - 'Accept': 'application/json', 'Content-Type': 'application/json', 'Authorization': 'Bearer special-key', } diff --git a/samples/openapi3/server/petstore/python-flask-python2/requirements.txt b/samples/openapi3/server/petstore/python-flask-python2/requirements.txt index 47350085aa10..55ef66307fc4 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/requirements.txt +++ b/samples/openapi3/server/petstore/python-flask-python2/requirements.txt @@ -1,8 +1,16 @@ -connexion >= 2.6.0; python_version>="3.6" -connexion >= 2.3.0; python_version=="3.5" -connexion >= 2.3.0; python_version=="3.4" -connexion == 2.4.0; python_version<="2.7" +connexion[swagger-ui] >= 2.6.0; python_version>="3.6" +# 2.3 is the last version that supports python 3.4-3.5 +connexion[swagger-ui] <= 2.3.0; python_version=="3.5" or python_version=="3.4" +connexion[swagger-ui] == 2.4.0; python_version<="2.7" +# connexion requires werkzeug but connexion < 2.4.0 does not install werkzeug +# we must peg werkzeug versions below to fix connexion +# https://github.com/zalando/connexion/pull/1044 +werkzeug == 0.16.1; python_version=="3.5" or python_version=="3.4" swagger-ui-bundle >= 0.0.2 python_dateutil >= 2.6.0 typing >= 3.5.2.2 +# For specs with timestamps, pyyaml 5.3 broke connexion's spec parsing in python 2. +# Connexion uses copy.deepcopy() on the spec, thus hitting this bug: +# https://github.com/yaml/pyyaml/issues/387 +pyyaml < 5.3; python_version<="2.7" setuptools >= 21.0.0 diff --git a/samples/openapi3/server/petstore/python-flask-python2/test-requirements.txt b/samples/openapi3/server/petstore/python-flask-python2/test-requirements.txt index a2626d875ff4..0970f28c7c5a 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/test-requirements.txt +++ b/samples/openapi3/server/petstore/python-flask-python2/test-requirements.txt @@ -1,4 +1,4 @@ pytest~=4.6.7 # needed for python 2.7+3.4 pytest-cov>=2.8.1 pytest-randomly==1.2.3 # needed for python 2.7+3.4 -flask_testing==0.6.1 \ No newline at end of file +Flask-Testing==0.8.0 diff --git a/samples/openapi3/server/petstore/python-flask-python2/tox.ini b/samples/openapi3/server/petstore/python-flask-python2/tox.ini index d05c607610ce..d63c4ac5aac0 100644 --- a/samples/openapi3/server/petstore/python-flask-python2/tox.ini +++ b/samples/openapi3/server/petstore/python-flask-python2/tox.ini @@ -1,9 +1,11 @@ [tox] envlist = py27, py3 +skipsdist=True [testenv] deps=-r{toxinidir}/requirements.txt -r{toxinidir}/test-requirements.txt + {toxinidir} commands= - pytest --cov=openapi_server \ No newline at end of file + pytest --cov=openapi_server diff --git a/samples/openapi3/server/petstore/python-flask/.openapi-generator/VERSION b/samples/openapi3/server/petstore/python-flask/.openapi-generator/VERSION index bfbf77eb7fad..d99e7162d01f 100644 --- a/samples/openapi3/server/petstore/python-flask/.openapi-generator/VERSION +++ b/samples/openapi3/server/petstore/python-flask/.openapi-generator/VERSION @@ -1 +1 @@ -4.3.0-SNAPSHOT \ No newline at end of file +5.0.0-SNAPSHOT \ No newline at end of file diff --git a/samples/openapi3/server/petstore/python-flask/openapi_server/controllers/pet_controller.py b/samples/openapi3/server/petstore/python-flask/openapi_server/controllers/pet_controller.py index 20b15fabbd98..5ae8f380ee38 100644 --- a/samples/openapi3/server/petstore/python-flask/openapi_server/controllers/pet_controller.py +++ b/samples/openapi3/server/petstore/python-flask/openapi_server/controllers/pet_controller.py @@ -17,7 +17,7 @@ def add_pet(pet): # noqa: E501 :param pet: Pet object that needs to be added to the store :type pet: dict | bytes - :rtype: Pet + :rtype: None """ if connexion.request.is_json: pet = Pet.from_dict(connexion.request.get_json()) # noqa: E501 @@ -86,7 +86,7 @@ def update_pet(pet): # noqa: E501 :param pet: Pet object that needs to be added to the store :type pet: dict | bytes - :rtype: Pet + :rtype: None """ if connexion.request.is_json: pet = Pet.from_dict(connexion.request.get_json()) # noqa: E501 diff --git a/samples/openapi3/server/petstore/python-flask/openapi_server/openapi/openapi.yaml b/samples/openapi3/server/petstore/python-flask/openapi_server/openapi/openapi.yaml index 142289318ae3..31100fda5278 100644 --- a/samples/openapi3/server/petstore/python-flask/openapi_server/openapi/openapi.yaml +++ b/samples/openapi3/server/petstore/python-flask/openapi_server/openapi/openapi.yaml @@ -26,15 +26,6 @@ paths: requestBody: $ref: '#/components/requestBodies/Pet' responses: - "200": - content: - application/xml: - schema: - $ref: '#/components/schemas/Pet' - application/json: - schema: - $ref: '#/components/schemas/Pet' - description: successful operation "405": description: Invalid input security: @@ -50,15 +41,6 @@ paths: requestBody: $ref: '#/components/requestBodies/Pet' responses: - "200": - content: - application/xml: - schema: - $ref: '#/components/schemas/Pet' - application/json: - schema: - $ref: '#/components/schemas/Pet' - description: successful operation "400": description: Invalid ID supplied "404": diff --git a/samples/openapi3/server/petstore/python-flask/openapi_server/test/test_pet_controller.py b/samples/openapi3/server/petstore/python-flask/openapi_server/test/test_pet_controller.py index be94fa8d5af5..2e9944b3cc33 100644 --- a/samples/openapi3/server/petstore/python-flask/openapi_server/test/test_pet_controller.py +++ b/samples/openapi3/server/petstore/python-flask/openapi_server/test/test_pet_controller.py @@ -41,7 +41,6 @@ def test_add_pet(self): "status" : "available" } headers = { - 'Accept': 'application/json', 'Content-Type': 'application/json', 'Authorization': 'Bearer special-key', } @@ -146,7 +145,6 @@ def test_update_pet(self): "status" : "available" } headers = { - 'Accept': 'application/json', 'Content-Type': 'application/json', 'Authorization': 'Bearer special-key', } diff --git a/samples/openapi3/server/petstore/python-flask/requirements.txt b/samples/openapi3/server/petstore/python-flask/requirements.txt index 2639eedf1361..72ed547c4429 100644 --- a/samples/openapi3/server/petstore/python-flask/requirements.txt +++ b/samples/openapi3/server/petstore/python-flask/requirements.txt @@ -1,7 +1,10 @@ -connexion >= 2.6.0; python_version>="3.6" -connexion >= 2.3.0; python_version=="3.5" -connexion >= 2.3.0; python_version=="3.4" -connexion == 2.4.0; python_version<="2.7" +connexion[swagger-ui] >= 2.6.0; python_version>="3.6" +# 2.3 is the last version that supports python 3.4-3.5 +connexion[swagger-ui] <= 2.3.0; python_version=="3.5" or python_version=="3.4" +# connexion requires werkzeug but connexion < 2.4.0 does not install werkzeug +# we must peg werkzeug versions below to fix connexion +# https://github.com/zalando/connexion/pull/1044 +werkzeug == 0.16.1; python_version=="3.5" or python_version=="3.4" swagger-ui-bundle >= 0.0.2 python_dateutil >= 2.6.0 setuptools >= 21.0.0 diff --git a/samples/openapi3/server/petstore/python-flask/test-requirements.txt b/samples/openapi3/server/petstore/python-flask/test-requirements.txt index a2626d875ff4..0970f28c7c5a 100644 --- a/samples/openapi3/server/petstore/python-flask/test-requirements.txt +++ b/samples/openapi3/server/petstore/python-flask/test-requirements.txt @@ -1,4 +1,4 @@ pytest~=4.6.7 # needed for python 2.7+3.4 pytest-cov>=2.8.1 pytest-randomly==1.2.3 # needed for python 2.7+3.4 -flask_testing==0.6.1 \ No newline at end of file +Flask-Testing==0.8.0 diff --git a/samples/openapi3/server/petstore/python-flask/tox.ini b/samples/openapi3/server/petstore/python-flask/tox.ini index cff71191e6cb..f66b2d84cdaa 100644 --- a/samples/openapi3/server/petstore/python-flask/tox.ini +++ b/samples/openapi3/server/petstore/python-flask/tox.ini @@ -1,9 +1,11 @@ [tox] envlist = py3 +skipsdist=True [testenv] deps=-r{toxinidir}/requirements.txt -r{toxinidir}/test-requirements.txt + {toxinidir} commands= - pytest --cov=openapi_server \ No newline at end of file + pytest --cov=openapi_server