@kattebak/openapi-generator-ts 1.0.0

package/templates/python/model_oneof.mustache

@@ -0,0 +1,209 @@
+from __future__ import annotations
+import json
+import pprint
+{{#vendorExtensions.x-py-other-imports}}
+{{{.}}}
+{{/vendorExtensions.x-py-other-imports}}
+{{#vendorExtensions.x-py-model-imports}}
+{{{.}}}
+{{/vendorExtensions.x-py-model-imports}}
+from pydantic import StrictStr, Field
+from typing import Union, List, Set, Optional, Dict
+from typing_extensions import Literal, Self
+
+{{#uppercase}}{{{classname}}}{{/uppercase}}_ONE_OF_SCHEMAS = [{{#oneOf}}"{{.}}"{{#unless @last}}, {{/unless}}{{/oneOf}}]
+
+class {{classname}}({{#parent}}{{{.}}}{{/parent}}{{^parent}}BaseModel{{/parent}}):
+    """
+    {{{description}}}{{#unless description}}{{{classname}}}{{/unless}}
+    """
+{{#composedSchemas.oneOf}}
+    # data type: {{{dataType}}}
+    {{vendorExtensions.x-py-name}}: {{{vendorExtensions.x-py-typing}}}
+{{/composedSchemas.oneOf}}
+    actual_instance: Optional[Union[{{#oneOf}}{{{.}}}{{#unless @last}}, {{/unless}}{{/oneOf}}]] = None
+    one_of_schemas: Set[str] = { {{#oneOf}}"{{.}}"{{#unless @last}}, {{/unless}}{{/oneOf}} }
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        protected_namespaces=(),
+    )
+
+{{#discriminator}}
+
+    discriminator_value_class_map: Dict[str, str] = {
+{{#children}}
+        '{{^vendorExtensions.x-discriminator-value}}{{name}}{{/vendorExtensions.x-discriminator-value}}{{#vendorExtensions.x-discriminator-value}}{{{vendorExtensions.x-discriminator-value}}}{{/vendorExtensions.x-discriminator-value}}': '{{{classname}}}'{{#unless @last}},{{/unless}}
+{{/children}}
+    }
+{{/discriminator}}
+
+    def __init__(self, *args, **kwargs) -> None:
+        if args:
+            if len(args) > 1:
+                raise ValueError("If a position argument is used, only 1 is allowed to set `actual_instance`")
+            if kwargs:
+                raise ValueError("If a position argument is used, keyword arguments cannot be used.")
+            super().__init__(actual_instance=args[0])
+        else:
+            super().__init__(**kwargs)
+
+    @field_validator('actual_instance')
+    def actual_instance_must_validate_oneof(cls, v):
+        {{#isNullable}}
+        if v is None:
+            return v
+
+        {{/isNullable}}
+        instance = {{{classname}}}.model_construct()
+        error_messages = []
+        match = 0
+        {{#composedSchemas.oneOf}}
+        # validate data type: {{{dataType}}}
+        {{#isContainer}}
+        try:
+            instance.{{vendorExtensions.x-py-name}} = v
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        {{/isContainer}}
+        {{^isContainer}}
+        {{#isPrimitiveType}}
+        try:
+            instance.{{vendorExtensions.x-py-name}} = v
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        {{/isPrimitiveType}}
+        {{^isPrimitiveType}}
+        if not isinstance(v, {{{dataType}}}):
+            error_messages.append(f"Error! Input type `{type(v)}` is not `{{{dataType}}}`")
+        else:
+            match += 1
+        {{/isPrimitiveType}}
+        {{/isContainer}}
+        {{/composedSchemas.oneOf}}
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when setting `actual_instance` in {{{classname}}} with oneOf schemas: {{#oneOf}}{{{.}}}{{#unless @last}}, {{/unless}}{{/oneOf}}. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when setting `actual_instance` in {{{classname}}} with oneOf schemas: {{#oneOf}}{{{.}}}{{#unless @last}}, {{/unless}}{{/oneOf}}. Details: " + ", ".join(error_messages))
+        else:
+            return v
+
+    @classmethod
+    def from_dict(cls, obj: Union[str, Dict[str, Any]]) -> Self:
+        return cls.from_json(json.dumps(obj))
+
+    @classmethod
+    {{#isNullable}}
+    def from_json(cls, json_str: Optional[str]) -> Self:
+    {{/isNullable}}
+    {{^isNullable}}
+    def from_json(cls, json_str: str) -> Self:
+    {{/isNullable}}
+        """Returns the object represented by the json string"""
+        instance = cls.model_construct()
+        {{#isNullable}}
+        if json_str is None:
+            return instance
+
+        {{/isNullable}}
+        error_messages = []
+        match = 0
+
+        {{#useOneOfDiscriminatorLookup}}
+        {{#discriminator}}
+        {{#mappedModels}}
+        {{#if @first}}
+        # use oneOf discriminator to lookup the data type
+        _data_type = json.loads(json_str).get("{{{propertyBaseName}}}")
+        if not _data_type:
+            raise ValueError("Failed to lookup data type from the field `{{{propertyBaseName}}}` in the input.")
+
+        {{/if}}
+        # check if data type is `{{{modelName}}}`
+        if _data_type == "{{{mappingName}}}":
+            instance.actual_instance = {{{modelName}}}.from_json(json_str)
+            return instance
+
+        {{/mappedModels}}
+        {{/discriminator}}
+        {{/useOneOfDiscriminatorLookup}}
+        {{#composedSchemas.oneOf}}
+        {{#isContainer}}
+        # deserialize data into {{{dataType}}}
+        try:
+            # validation
+            instance.{{vendorExtensions.x-py-name}} = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.{{vendorExtensions.x-py-name}}
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        {{/isContainer}}
+        {{^isContainer}}
+        {{#isPrimitiveType}}
+        # deserialize data into {{{dataType}}}
+        try:
+            # validation
+            instance.{{vendorExtensions.x-py-name}} = json.loads(json_str)
+            # assign value to actual_instance
+            instance.actual_instance = instance.{{vendorExtensions.x-py-name}}
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        {{/isPrimitiveType}}
+        {{^isPrimitiveType}}
+        # deserialize data into {{{dataType}}}
+        try:
+            instance.actual_instance = {{{dataType}}}.from_json(json_str)
+            match += 1
+        except (ValidationError, ValueError) as e:
+            error_messages.append(str(e))
+        {{/isPrimitiveType}}
+        {{/isContainer}}
+        {{/composedSchemas.oneOf}}
+
+        if match > 1:
+            # more than 1 match
+            raise ValueError("Multiple matches found when deserializing the JSON string into {{{classname}}} with oneOf schemas: {{#oneOf}}{{{.}}}{{#unless @last}}, {{/unless}}{{/oneOf}}. Details: " + ", ".join(error_messages))
+        elif match == 0:
+            # no match
+            raise ValueError("No match found when deserializing the JSON string into {{{classname}}} with oneOf schemas: {{#oneOf}}{{{.}}}{{#unless @last}}, {{/unless}}{{/oneOf}}. Details: " + ", ".join(error_messages))
+        else:
+            return instance
+
+    def to_json(self) -> str:
+        """Returns the JSON representation of the actual instance"""
+        if self.actual_instance is None:
+            return "null"
+
+        if hasattr(self.actual_instance, "to_json") and callable(self.actual_instance.to_json):
+            return self.actual_instance.to_json()
+        else:
+            return json.dumps(self.actual_instance)
+
+    def to_dict(self) -> Optional[Union[Dict[str, Any], {{#oneOf}}{{{.}}}{{#unless @last}}, {{/unless}}{{/oneOf}}]]:
+        """Returns the dict representation of the actual instance"""
+        if self.actual_instance is None:
+            return None
+
+        if hasattr(self.actual_instance, "to_dict") and callable(self.actual_instance.to_dict):
+            return self.actual_instance.to_dict()
+        else:
+            # primitive type
+            return self.actual_instance
+
+    def to_str(self) -> str:
+        """Returns the string representation of the actual instance"""
+        return pprint.pformat(self.model_dump())
+
+{{#vendorExtensions.x-py-postponed-model-imports.size}}
+{{#vendorExtensions.x-py-postponed-model-imports}}
+{{{.}}}
+{{/vendorExtensions.x-py-postponed-model-imports}}
+# TODO: Rewrite to not use raise_errors
+{{classname}}.model_rebuild(raise_errors=False)
+{{/vendorExtensions.x-py-postponed-model-imports.size}}

package/templates/python/model_test.mustache

@@ -0,0 +1,60 @@
+# coding: utf-8
+
+{{>partial_header}}
+
+
+import unittest
+
+{{#models}}
+{{#model}}
+from {{modelPackage}}.{{classFilename}} import {{classname}}
+
+class Test{{classname}}(unittest.TestCase):
+    """{{classname}} unit test stubs"""
+
+    def setUp(self):
+        pass
+
+    def tearDown(self):
+        pass
+{{^isEnum}}
+
+    def make_instance(self, include_optional) -> {{classname}}:
+        """Test {{classname}}
+            include_optional is a boolean, when False only required
+            params are included, when True both required and
+            optional params are included """
+        # uncomment below to create an instance of `{{{classname}}}`
+        """
+        model = {{classname}}()
+        if include_optional:
+            return {{classname}}(
+                {{#vars}}
+                {{name}} = {{{example}}}{{#unless example}}None{{/unless}}{{#unless @last}},{{/unless}}
+                {{/vars}}
+            )
+        else:
+            return {{classname}}(
+                {{#vars}}
+                {{#required}}
+                {{name}} = {{{example}}}{{#unless example}}None{{/unless}},
+                {{/required}}
+                {{/vars}}
+        )
+        """
+{{/isEnum}}
+
+    def test{{classname}}(self):
+        """Test {{classname}}"""
+{{^isEnum}}
+        # inst_req_only = self.make_instance(include_optional=False)
+        # inst_req_and_optional = self.make_instance(include_optional=True)
+{{/isEnum}}
+{{#isEnum}}
+        # inst = {{{classname}}}()
+{{/isEnum}}
+{{/model}}
+{{/models}}
+
+if __name__ == '__main__':
+    unittest.main()

package/templates/python/partial_api.mustache

@@ -0,0 +1,52 @@
+        """{{#isDeprecated}}(Deprecated) {{/isDeprecated}}{{{summary}}}{{#unless summary}}{{operationId}}{{/unless}}
+
+        {{#if notes}}
+        {{{notes}}}
+        {{/if}}
+
+        {{#allParams}}
+        :param {{paramName}}:{{#if description}} {{{description}}}{{/if}}{{#required}} (required){{/required}}{{#optional}}(optional){{/optional}}
+        :type {{paramName}}: {{dataType}}{{#optional}}, optional{{/optional}}
+        {{/allParams}}
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :type _request_timeout: int, tuple(int, int), optional
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the
+                              authentication in the spec for a single request.
+        :type _request_auth: dict, optional
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+        {{#isDeprecated}}
+        warnings.warn("{{{httpMethod}}} {{{path}}} is deprecated.", DeprecationWarning)
+        {{/isDeprecated}}
+
+        _param = self._{{operationId}}_serialize(
+            {{#allParams}}
+            {{paramName}}={{paramName}},
+            {{/allParams}}
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            {{#responses}}
+            {{^isWildcard}}
+            '{{code}}': {{#dataType}}"{{.}}"{{/dataType}}{{^dataType}}None{{/dataType}},
+            {{/isWildcard}}
+            {{/responses}}
+        }

package/templates/python/partial_api_args.mustache

@@ -0,0 +1,18 @@
+(
+        self,
+        {{#allParams}}
+        {{paramName}}: {{{vendorExtensions.x-py-typing}}}{{^required}} = None{{/required}},
+        {{/allParams}}
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le={{#servers.size}}{{servers.size}}{{/servers.size}}{{^servers.size}}1{{/servers.size}})] = 0,
+    )

package/templates/python/partial_header.mustache

@@ -0,0 +1,19 @@
+"""
+{{#if appName}}
+    {{{appName}}}
+
+{{/if}}
+{{#if appDescription}}
+    {{{appDescription}}}
+
+{{/if}}
+    {{#if version}}
+    The version of the OpenAPI document: {{{version}}}
+    {{/if}}
+    {{#if infoEmail}}
+    Contact: {{{infoEmail}}}
+    {{/if}}
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501

package/templates/python/py.typed.mustache

@@ -0,0 +1 @@
+

package/templates/python/pyproject.mustache

@@ -0,0 +1,172 @@
+{{#poetry1}}
+[tool.poetry]
+{{/poetry1}}
+{{^poetry1}}
+[project]
+{{/poetry1}}
+name = "{{{packageName}}}"
+version = "{{{packageVersion}}}"
+description = "{{{appName}}}"
+{{#poetry1}}
+authors = ["{{infoName}}{{^infoName}}OpenAPI Generator Community{{/infoName}} <{{infoEmail}}{{#unless infoEmail}}team@openapitools.org{{/unless}}>"]
+{{/poetry1}}
+{{^poetry1}}
+authors = [
+  {name = "{{infoName}}{{^infoName}}OpenAPI Generator Community{{/infoName}}",email = "{{infoEmail}}{{#unless infoEmail}}team@openapitools.org{{/unless}}"},
+]
+{{/poetry1}}
+{{#if licenseInfo}}
+{{#poetry1}}
+license = "{{{licenseInfo}}}"
+{{/poetry1}}
+{{^poetry1}}
+license = { text = "{{{licenseInfo}}}" }
+{{/poetry1}}
+{{/if}}
+readme = "README.md"
+{{#poetry1}}
+repository = "https://{{{gitHost}}}/{{{gitUserId}}}/{{{gitRepoId}}}"
+{{/poetry1}}
+keywords = ["OpenAPI", "OpenAPI-Generator", "{{{appName}}}"]
+{{#poetry1}}
+include = ["{{packageName}}/py.typed"]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+{{^async}}
+urllib3 = ">= 2.[1].0, < 3.[0].0"
+{{/async}}
+python-dateutil = ">= 2.[8].2"
+{{#asyncio}}
+aiohttp = ">= 3.[8].4"
+aiohttp-retry = ">= 2.[8].3"
+{{/asyncio}}
+{{#httpx}}
+httpx = ">= 0.[28].1"
+{{/httpx}}
+{{#tornado}}
+tornado = ">=4.2, <5"
+{{/tornado}}
+{{#hasHttpSignatureMethods}}
+pem = ">= 19.[3].0"
+pycryptodome = ">= 3.[9].0"
+{{/hasHttpSignatureMethods}}
+pydantic = ">= 2"
+typing-extensions = ">= 4.[7].1"
+{{#lazyImports}}
+lazy-imports = ">= 1, < 2"
+{{/lazyImports}}
+{{/poetry1}}
+{{^poetry1}}
+requires-python = ">=3.9"
+
+dependencies = [
+{{^async}}
+  "urllib3 (>=2.[1].0,<3.[0].0)",
+{{/async}}
+  "python-dateutil (>=2.[8].2)",
+{{#httpx}}
+  "httpx (>=0.[28].1)",
+{{/httpx}}
+{{#asyncio}}
+  "aiohttp (>=3.[8].4)",
+  "aiohttp-retry (>=2.[8].3)",
+{{/asyncio}}
+{{#tornado}}
+  "tornado (>=4.2,<5)",
+{{/tornado}}
+{{#hasHttpSignatureMethods}}
+  "pem (>=19.[3].0)",
+  "pycryptodome (>=3.[9].0)",
+{{/hasHttpSignatureMethods}}
+  "pydantic (>=2)",
+  "typing-extensions (>=4.[7].1)",
+{{#lazyImports}}
+  "lazy-imports (>=1,<2)"
+{{/lazyImports}}
+]
+
+[project.urls]
+Repository = "https://{{{gitHost}}}/{{{gitUserId}}}/{{{gitRepoId}}}"
+
+{{/poetry1}}
+{{^poetry1}}
+[tool.poetry]
+requires-poetry = ">=2.0"
+{{/poetry1}}
+
+{{#poetry1}}
+[tool.poetry.dev-dependencies]
+{{/poetry1}}
+{{^poetry1}}
+[tool.poetry.group.dev.dependencies]
+{{/poetry1}}
+pytest = ">= 7.[2].1"
+pytest-cov = ">= 2.[8].1"
+tox = ">= 3.[9].0"
+flake8 = ">= 4.[0].0"
+types-python-dateutil = ">= 2.[8].19.14"
+mypy = ">= 1.5"
+
+
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[tool.pylint.'MESSAGES CONTROL']
+extension-pkg-whitelist = "pydantic"
+
+[tool.mypy]
+files = [
+  "{{{packageName}}}",
+  #"test",  # auto-generated tests
+  "tests", # hand-written tests
+]
+# TODO: enable "strict" once all these individual checks are passing
+# strict = true
+
+# List from: https://mypy.readthedocs.io/en/stable/existing_code.html#introduce-stricter-options
+warn_unused_configs = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+
+## Getting these passing should be easy
+strict_equality = true
+extra_checks = true
+
+## Strongly recommend enabling this one as soon as you can
+check_untyped_defs = true
+
+## These shouldn't be too much additional work, but may be tricky to
+## get passing if you use a lot of untyped libraries
+disallow_subclassing_any = true
+disallow_untyped_decorators = true
+disallow_any_generics = true
+
+### These next few are various gradations of forcing use of type annotations
+#disallow_untyped_calls = true
+#disallow_incomplete_defs = true
+#disallow_untyped_defs = true
+#
+### This one isn't too hard to get passing, but return on investment is lower
+#no_implicit_reexport = true
+#
+### This one can be tricky to get passing if you use a lot of untyped libraries
+#warn_return_any = true
+
+[[tool.mypy.overrides]]
+module = [
+  "{{{packageName}}}.configuration",
+]
+warn_unused_ignores = true
+strict_equality = true
+extra_checks = true
+check_untyped_defs = true
+disallow_subclassing_any = true
+disallow_untyped_decorators = true
+disallow_any_generics = true
+disallow_untyped_calls = true
+disallow_incomplete_defs = true
+disallow_untyped_defs = true
+no_implicit_reexport = true
+warn_return_any = true

package/templates/python/python_doc_auth_partial.mustache

@@ -0,0 +1,108 @@
+# Defining the host is optional and defaults to {{{basePath}}}
+# See configuration.py for a list of all supported configuration parameters.
+configuration = {{{packageName}}}.Configuration(
+    host = "{{{basePath}}}"
+)
+
+{{#hasAuthMethods}}
+# The client must configure the authentication and authorization parameters
+# in accordance with the API server security policy.
+# Examples for each auth method are provided below, use the example that
+# satisfies your auth use case.
+{{#authMethods}}
+{{#isBasic}}
+{{#isBasicBasic}}
+
+# Configure HTTP basic authorization: {{{name}}}
+configuration = {{{packageName}}}.Configuration(
+    username = os.environ["USERNAME"],
+    password = os.environ["PASSWORD"]
+)
+{{/isBasicBasic}}
+{{#isBasicBearer}}
+
+# Configure Bearer authorization{{#bearerFormat}} ({{{.}}}){{/bearerFormat}}: {{{name}}}
+configuration = {{{packageName}}}.Configuration(
+    access_token = os.environ["BEARER_TOKEN"]
+)
+{{/isBasicBearer}}
+{{#isHttpSignature}}
+
+# Configure HTTP message signature: {{{name}}}
+# The HTTP Signature Header mechanism that can be used by a client to
+# authenticate the sender of a message and ensure that particular headers
+# have not been modified in transit.
+#
+# You can specify the signing key-id, private key path, signing scheme,
+# signing algorithm, list of signed headers and signature max validity.
+# The 'key_id' parameter is an opaque string that the API server can use
+# to lookup the client and validate the signature.
+# The 'private_key_path' parameter should be the path to a file that
+# contains a DER or base-64 encoded private key.
+# The 'private_key_passphrase' parameter is optional. Set the passphrase
+# if the private key is encrypted.
+# The 'signed_headers' parameter is used to specify the list of
+# HTTP headers included when generating the signature for the message.
+# You can specify HTTP headers that you want to protect with a cryptographic
+# signature. Note that proxies may add, modify or remove HTTP headers
+# for legitimate reasons, so you should only add headers that you know
+# will not be modified. For example, if you want to protect the HTTP request
+# body, you can specify the Digest header. In that case, the client calculates
+# the digest of the HTTP request body and includes the digest in the message
+# signature.
+# The 'signature_max_validity' parameter is optional. It is configured as a
+# duration to express when the signature ceases to be valid. The client calculates
+# the expiration date every time it generates the cryptographic signature
+# of an HTTP request. The API server may have its own security policy
+# that controls the maximum validity of the signature. The client max validity
+# must be lower than the server max validity.
+# The time on the client and server must be synchronized, otherwise the
+# server may reject the client signature.
+#
+# The client must use a combination of private key, signing scheme,
+# signing algorithm and hash algorithm that matches the security policy of
+# the API server.
+#
+# See {{{packageName}}}.signing for a list of all supported parameters.
+from {{{packageName}}} import signing
+import datetime
+
+configuration = {{{packageName}}}.Configuration(
+    host = "{{{basePath}}}",
+    signing_info = {{{packageName}}}.HttpSigningConfiguration(
+        key_id = 'my-key-id',
+        private_key_path = 'private_key.pem',
+        private_key_passphrase = 'YOUR_PASSPHRASE',
+        signing_scheme = {{{packageName}}}.signing.SCHEME_HS2019,
+        signing_algorithm = {{{packageName}}}.signing.ALGORITHM_ECDSA_MODE_FIPS_186_3,
+        hash_algorithm = {{{packageName}}}.signing.SCHEME_RSA_SHA256,
+        signed_headers = [
+                            {{{packageName}}}.signing.HEADER_REQUEST_TARGET,
+                            {{{packageName}}}.signing.HEADER_CREATED,
+                            {{{packageName}}}.signing.HEADER_EXPIRES,
+                            {{{packageName}}}.signing.HEADER_HOST,
+                            {{{packageName}}}.signing.HEADER_DATE,
+                            {{{packageName}}}.signing.HEADER_DIGEST,
+                            'Content-Type',
+                            'Content-Length',
+                            'User-Agent'
+                         ],
+        signature_max_validity = datetime.timedelta(minutes=5)
+    )
+)
+{{/isHttpSignature}}
+{{/isBasic}}
+{{#isApiKey}}
+
+# Configure API key authorization: {{{name}}}
+configuration.api_key['{{{name}}}'] = os.environ["API_KEY"]
+
+# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
+# configuration.api_key_prefix['{{name}}'] = 'Bearer'
+{{/isApiKey}}
+{{#isOAuth}}
+
+configuration.access_token = os.environ["ACCESS_TOKEN"]
+{{/isOAuth}}
+{{/authMethods}}
+{{/hasAuthMethods}}

package/templates/python/requirements.mustache

@@ -0,0 +1,23 @@
+{{^async}}
+urllib3 >= 2.[1].0, < 3.[0].0
+{{/async}}
+python_dateutil >= 2.[8].2
+{{#asyncio}}
+aiohttp >= 3.[8].4
+aiohttp-retry >= 2.[8].3
+{{/asyncio}}
+{{#httpx}}
+httpx = ">= 0.[28].1"
+{{/httpx}}
+{{#tornado}}
+tornado = ">= 4.2, < 5"
+{{/tornado}}
+{{#hasHttpSignatureMethods}}
+pem >= 19.[3].0
+pycryptodome >= 3.[9].0
+{{/hasHttpSignatureMethods}}
+pydantic >= 2
+typing-extensions >= 4.[7].1
+{{#lazyImports}}
+lazy-imports >= 1, < 2
+{{/lazyImports}}