ab-openapi-python-generator 2.1.4__py3-none-any.whl → 2.2.0__py3-none-any.whl

ab_openapi_python_generator/language_converters/python/jinja_config.py

@@ -7,12 +7,11 @@ from . import common
 ENUM_TEMPLATE = "enum.jinja2"
 MODELS_TEMPLATE = "models.jinja2"
 MODELS_TEMPLATE_PYDANTIC_V2 = "models_pydantic_2.jinja2"
-SERVICE_TEMPLATE = "service.jinja2"
-HTTPX_TEMPLATE = "httpx.jinja2"
-API_CONFIG_TEMPLATE = "apiconfig.jinja2"
-API_CONFIG_TEMPLATE_PYDANTIC_V2 = "apiconfig_pydantic_2.jinja2"
 ALIAS_UNION_TEMPLATE = "alias_union.jinja2"
 DISCRIMINATOR_ENUM_TEMPLATE = "discriminator_enum.jinja2"
+HTTP_EXCEPTION_TEMPLATE = "http_exception.jinja2"
+SYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2 = "sync_client_httpx_pydantic_2.jinja2"
+ASYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2 = "async_client_httpx_pydantic_2.jinja2"
 TEMPLATE_PATH = Path(__file__).parent / "templates"
 
 

ab_openapi_python_generator/language_converters/python/model_generator.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import itertools
 import re
+from dataclasses import dataclass
 from typing import Dict, List, Optional, Set, Tuple, Union
 
 import click
@@ -27,15 +28,13 @@ from openapi_pydantic.v3.v3_1 import (
 from ab_openapi_python_generator.common import PydanticVersion
 from ab_openapi_python_generator.language_converters.python import common
 from ab_openapi_python_generator.language_converters.python.jinja_config import (
+    ALIAS_UNION_TEMPLATE,
+    DISCRIMINATOR_ENUM_TEMPLATE,
     ENUM_TEMPLATE,
     MODELS_TEMPLATE,
     MODELS_TEMPLATE_PYDANTIC_V2,
-    ALIAS_UNION_TEMPLATE,
-    DISCRIMINATOR_ENUM_TEMPLATE,
     create_jinja_env,
 )
-from dataclasses import dataclass
-
 from ab_openapi_python_generator.models import Model, Property, TypeConversion
 
 # Type aliases for compatibility
@@ -305,10 +304,7 @@ def _build_discriminator_bindings(components: Components) -> Dict[str, Discrimin
         if discriminator_key is None:
             continue
 
-        enum_name = (
-            f"{_pascal_schema_name(schema_name)}"
-            f"{_pascal_discriminator(discriminator_key)}"
-        )
+        enum_name = f"{_pascal_schema_name(schema_name)}{_pascal_discriminator(discriminator_key)}"
 
         mapping = getattr(disc, "mapping", None) or {}
         # invert mapping to get $ref -> value
@@ -366,11 +362,7 @@ def type_converter(  # noqa: C901
         return TypeConversion(
             original_type=schema.ref,
             converted_type=converted_type,
-            import_types=(
-                [f"from .{import_type} import {import_type}"]
-                if import_type != model_name
-                else None
-            ),
+            import_types=([f"from .{import_type} import {import_type}"] if import_type != model_name else None),
         )
 
     if required:
@@ -383,7 +375,9 @@ def type_converter(  # noqa: C901
     original_type = (
         schema.type.value
         if hasattr(schema.type, "value") and schema.type is not None
-        else str(schema.type) if schema.type is not None else "object"
+        else str(schema.type)
+        if schema.type is not None
+        else "object"
     )
     import_types: Optional[List[str]] = None
 
@@ -412,22 +406,16 @@ def type_converter(  # noqa: C901
                         )
                     )
 
-        original_type = (
-            "tuple<" + ",".join([i.original_type for i in conversions]) + ">"
-        )
+        original_type = "tuple<" + ",".join([i.original_type for i in conversions]) + ">"
         if len(conversions) == 1:
             converted_type = conversions[0].converted_type
         else:
-            converted_type = (
-                "Tuple[" + ",".join([i.converted_type for i in conversions]) + "]"
-            )
+            converted_type = "Tuple[" + ",".join([i.converted_type for i in conversions]) + "]"
 
         converted_type = pre_type + converted_type + post_type
         # Collect first import from referenced sub-schemas only (skip empty lists)
         import_types = [
-            i.import_types[0]
-            for i in conversions
-            if i.import_types is not None and len(i.import_types) > 0
+            i.import_types[0] for i in conversions if i.import_types is not None and len(i.import_types) > 0
         ] or None
 
     elif schema.oneOf is not None or schema.anyOf is not None:
@@ -447,23 +435,15 @@ def type_converter(  # noqa: C901
                         import_types=import_types,
                     )
                 )
-        original_type = (
-            "union<" + ",".join([i.original_type for i in conversions]) + ">"
-        )
+        original_type = "union<" + ",".join([i.original_type for i in conversions]) + ">"
 
         if len(conversions) == 1:
             converted_type = conversions[0].converted_type
         else:
-            converted_type = (
-                "Union[" + ",".join([i.converted_type for i in conversions]) + "]"
-            )
+            converted_type = "Union[" + ",".join([i.converted_type for i in conversions]) + "]"
 
         converted_type = pre_type + converted_type + post_type
-        import_types = list(
-            itertools.chain(
-                *[i.import_types for i in conversions if i.import_types is not None]
-            )
-        )
+        import_types = list(itertools.chain(*[i.import_types for i in conversions if i.import_types is not None]))
     # We only want to auto convert to datetime if orjson is used throghout the code, otherwise we can not
     # serialize it to JSON.
     elif (schema.type == "string" or str(schema.type) == "DataType.STRING") and (
@@ -483,9 +463,7 @@ def type_converter(  # noqa: C901
         else:
             converted_type = pre_type + "UUID" + post_type
             import_types = ["from uuid import UUID"]
-    elif (
-        schema.type == "string" or str(schema.type) == "DataType.STRING"
-    ) and schema.schema_format == "date-time":
+    elif (schema.type == "string" or str(schema.type) == "DataType.STRING") and schema.schema_format == "date-time":
         converted_type = pre_type + "datetime" + post_type
         import_types = ["from datetime import datetime"]
     elif schema.type == "integer" or str(schema.type) == "DataType.INTEGER":
@@ -496,9 +474,7 @@ def type_converter(  # noqa: C901
         converted_type = pre_type + "bool" + post_type
     elif schema.type == "array" or str(schema.type) == "DataType.ARRAY":
         retVal = pre_type + "List["
-        if isinstance(schema.items, Reference30) or isinstance(
-            schema.items, Reference31
-        ):
+        if isinstance(schema.items, Reference30) or isinstance(schema.items, Reference31):
             converted_reference = _generate_property_from_reference(
                 model_name or "", "", schema.items, schema, required
             )
@@ -535,10 +511,7 @@ def type_converter(  # noqa: C901
                     and schema.schema_format.startswith("uuid")
                     and common.get_use_orjson()
                 ):
-                    if (
-                        len(schema.schema_format) > 4
-                        and schema.schema_format[4].isnumeric()
-                    ):
+                    if len(schema.schema_format) > 4 and schema.schema_format[4].isnumeric():
                         uuid_type = schema.schema_format.upper()
                         converted_type = pre_type + uuid_type + post_type
                         import_types = ["from pydantic import " + uuid_type]
@@ -576,10 +549,7 @@ def type_converter(  # noqa: C901
                         and schema.schema_format.startswith("uuid")
                         and common.get_use_orjson()
                     ):
-                        if (
-                            len(schema.schema_format) > 4
-                            and schema.schema_format[4].isnumeric()
-                        ):
+                        if len(schema.schema_format) > 4 and schema.schema_format[4].isnumeric():
                             uuid_type = schema.schema_format.upper()
                             converted_type = pre_type + uuid_type + post_type
                             import_types = ["from pydantic import " + uuid_type]
@@ -630,11 +600,7 @@ def _generate_property_from_schema(
     :param parent_schema: Component this belongs to
     :return: Property
     """
-    required = (
-        parent_schema is not None
-        and parent_schema.required is not None
-        and name in parent_schema.required
-    )
+    required = parent_schema is not None and parent_schema.required is not None and name in parent_schema.required
 
     import_type = None
     if required:
@@ -666,26 +632,20 @@ def _generate_property_from_reference(
     :return: Property and model to be imported by the file
     """
     required = (
-        parent_schema is not None
-        and parent_schema.required is not None
-        and name in parent_schema.required
+        parent_schema is not None and parent_schema.required is not None and name in parent_schema.required
     ) or force_required
     import_model = common.normalize_symbol(reference.ref.split("/")[-1])
 
     if import_model == model_name:
         type_conv = TypeConversion(
             original_type=reference.ref,
-            converted_type=(
-                import_model if required else 'Optional["' + import_model + '"]'
-            ),
+            converted_type=(import_model if required else 'Optional["' + import_model + '"]'),
             import_types=None,
         )
     else:
         type_conv = TypeConversion(
             original_type=reference.ref,
-            converted_type=(
-                import_model if required else "Optional[" + import_model + "]"
-            ),
+            converted_type=(import_model if required else "Optional[" + import_model + "]"),
             import_types=[f"from .{import_model} import {import_model}"],
         )
     return Property(
@@ -697,9 +657,7 @@ def _generate_property_from_reference(
     )
 
 
-def generate_models(
-    components: Components, pydantic_version: PydanticVersion = PydanticVersion.V2
-) -> List[Model]:
+def generate_models(components: Components, pydantic_version: PydanticVersion = PydanticVersion.V2) -> List[Model]:
     """
     Receives components from an OpenAPI 3.0+ specification and generates the models from it.
     Additionally:
@@ -735,14 +693,10 @@ def generate_models(
         # --------------------------
         if schema_or_reference.enum is not None:
             value_dict = schema_or_reference.model_dump()
-            value_dict["enum"] = [
-                (common.normalize_symbol(str(i)).upper(), i) for i in value_dict["enum"]
-            ]
+            value_dict["enum"] = [(common.normalize_symbol(str(i)).upper(), i) for i in value_dict["enum"]]
             m = Model(
                 file_name=name,
-                content=jinja_env.get_template(ENUM_TEMPLATE).render(
-                    name=name, **value_dict
-                ),
+                content=jinja_env.get_template(ENUM_TEMPLATE).render(name=name, **value_dict),
                 openapi_object=schema_or_reference,
                 properties=[],
             )
@@ -758,30 +712,24 @@ def generate_models(
         # Normal models
         # --------------------------
         properties: List[Property] = []
-        property_iterator = (
-            schema_or_reference.properties.items()
-            if schema_or_reference.properties is not None
-            else {}
-        )
+        property_iterator = schema_or_reference.properties.items() if schema_or_reference.properties is not None else {}
 
         for prop_name, prop_schema in property_iterator:
             # Reference property
             if isinstance(prop_schema, Reference30) or isinstance(prop_schema, Reference31):
-                conv_property = _generate_property_from_reference(
-                    name, prop_name, prop_schema, schema_or_reference
-                )
+                conv_property = _generate_property_from_reference(name, prop_name, prop_schema, schema_or_reference)
                 properties.append(conv_property)
                 continue
 
             # Schema property
-            conv_property = _generate_property_from_schema(
-                name, prop_name, prop_schema, schema_or_reference
-            )
+            conv_property = _generate_property_from_schema(name, prop_name, prop_schema, schema_or_reference)
 
             # If this model is a discriminated union member, and this property
             # is the discriminator key, make it a Literal[...] with a default
             binding = discriminator_bindings.get(name)
-            if binding and common.normalize_symbol(conv_property.name) == common.normalize_symbol(binding.discriminator_key):
+            if binding and common.normalize_symbol(conv_property.name) == common.normalize_symbol(
+                binding.discriminator_key
+            ):
                 conv_property.required = True
                 conv_property.default = f"{binding.enum_name}.{binding.enum_member}"
 
@@ -845,11 +793,7 @@ def generate_models(
 
             properties.append(conv_property)
 
-        template_name = (
-            MODELS_TEMPLATE_PYDANTIC_V2
-            if pydantic_version == PydanticVersion.V2
-            else MODELS_TEMPLATE
-        )
+        template_name = MODELS_TEMPLATE_PYDANTIC_V2 if pydantic_version == PydanticVersion.V2 else MODELS_TEMPLATE
 
         generated_content = jinja_env.get_template(template_name).render(
             schema_name=name, schema=schema_or_reference, properties=properties
@@ -872,9 +816,7 @@ def generate_models(
     # Ensure enum modules for discriminators are included
     enum_models: List[Model] = []
     for enum_name, members in enum_members_by_name.items():
-        enum_content = jinja_env.get_template(DISCRIMINATOR_ENUM_TEMPLATE).render(
-            enum_name=enum_name, members=members
-        )
+        enum_content = jinja_env.get_template(DISCRIMINATOR_ENUM_TEMPLATE).render(enum_name=enum_name, members=members)
         try:
             compile(enum_content, "<string>", "exec")
         except SyntaxError as e:  # pragma: no cover

ab_openapi_python_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -0,0 +1,80 @@
+{% if env_token_name is not none %}import os{% endif %}
+
+from typing import Any, Dict, Optional, Union
+
+import httpx
+from pydantic import BaseModel
+
+from ..models import *
+{% set _base_path = servers[0].url if servers|length > 0 else "/" %}
+from ..exceptions import HTTPException
+
+
+class AsyncClient(BaseModel):
+    model_config = {"validate_assignment": True}
+
+    base_path: str = "{{ _base_path }}"
+    verify: Union[bool, str] = True
+{% if env_token_name is none %}
+    access_token: Optional[str] = None
+{% endif %}
+
+    def get_access_token(self) -> Optional[str]:
+{% if env_token_name is not none %}
+        try:
+            return os.environ["{{ env_token_name }}"]
+        except KeyError:
+            return None
+{% else %}
+        return self.access_token
+{% endif %}
+
+    def set_access_token(self, value: str) -> None:
+{% if env_token_name is not none %}
+        raise Exception(
+            "This client was generated with an environment variable for the access token. "
+            "Please set '{{ env_token_name }}'."
+        )
+{% else %}
+        self.access_token = value
+{% endif %}
+
+{% for op in operations %}
+    async def {{ op.operation_id }}(self{% if op.params %}, {{ op.params }}{% endif %}) -> Any:
+        base_path = self.base_path
+        path = f"{{ op.path_name }}"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer { self.get_access_token() }",
+        }
+
+        query_params: Dict[str, Any] = {
+{% for qp in op.query_params %}
+            {{ qp }},
+{% endfor %}
+        }
+        query_params = {k: v for (k, v) in query_params.items() if v is not None}
+
+        async with httpx.AsyncClient(base_url=base_path, verify=self.verify) as client:
+            response = await client.request(
+                "{{ op.method }}",
+                httpx.URL(path),
+                headers=headers,
+                params=query_params,
+{% if op.body_param %}
+                json={{ op.body_param }},
+{% endif %}
+            )
+
+        if response.status_code != {{ op.return_type.status_code }}:
+            raise HTTPException(
+                response.status_code,
+                f"{{ op.operation_id }} failed with status code: {response.status_code}",
+            )
+
+        body = None if {{ op.return_type.status_code }} == 204 else response.json()
+        return body
+
+{% endfor %}

ab_openapi_python_generator/language_converters/python/templates/http_exception.jinja2

@@ -0,0 +1,8 @@
+class HTTPException(Exception):
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"{status_code} {message}")
+
+    def __str__(self) -> str:
+        return f"{self.status_code} {self.message}"

ab_openapi_python_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -0,0 +1,80 @@
+{% if env_token_name is not none %}import os{% endif %}
+
+from typing import Any, Dict, Optional, Union
+
+import httpx
+from pydantic import BaseModel
+
+from ..models import *
+{% set _base_path = servers[0].url if servers|length > 0 else "/" %}
+from ..exceptions import HTTPException
+
+
+class SyncClient(BaseModel):
+    model_config = {"validate_assignment": True}
+
+    base_path: str = "{{ _base_path }}"
+    verify: Union[bool, str] = True
+{% if env_token_name is none %}
+    access_token: Optional[str] = None
+{% endif %}
+
+    def get_access_token(self) -> Optional[str]:
+{% if env_token_name is not none %}
+        try:
+            return os.environ["{{ env_token_name }}"]
+        except KeyError:
+            return None
+{% else %}
+        return self.access_token
+{% endif %}
+
+    def set_access_token(self, value: str) -> None:
+{% if env_token_name is not none %}
+        raise Exception(
+            "This client was generated with an environment variable for the access token. "
+            "Please set '{{ env_token_name }}'."
+        )
+{% else %}
+        self.access_token = value
+{% endif %}
+
+{% for op in operations %}
+    def {{ op.operation_id }}(self{% if op.params %}, {{ op.params }}{% endif %}) -> Any:
+        base_path = self.base_path
+        path = f"{{ op.path_name }}"
+
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+            "Authorization": f"Bearer { self.get_access_token() }",
+        }
+
+        query_params: Dict[str, Any] = {
+{% for qp in op.query_params %}
+            {{ qp }},
+{% endfor %}
+        }
+        query_params = {k: v for (k, v) in query_params.items() if v is not None}
+
+        with httpx.Client(base_url=base_path, verify=self.verify) as client:
+            response = client.request(
+                "{{ op.method }}",
+                httpx.URL(path),
+                headers=headers,
+                params=query_params,
+{% if op.body_param %}
+                json={{ op.body_param }},
+{% endif %}
+            )
+
+        if response.status_code != {{ op.return_type.status_code }}:
+            raise HTTPException(
+                response.status_code,
+                f"{{ op.operation_id }} failed with status code: {response.status_code}",
+            )
+
+        body = None if {{ op.return_type.status_code }} == 204 else response.json()
+        return body
+
+{% endfor %}

ab_openapi_python_generator/models.py

@@ -18,7 +18,7 @@ from openapi_pydantic.v3.v3_1 import (
 from openapi_pydantic.v3.v3_1 import (
     Schema as Schema31,
 )
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 
 # Type unions for compatibility with both OpenAPI 3.0 and 3.1
 Operation = Union[Operation30, Operation31]
@@ -76,7 +76,7 @@ class Property(BaseModel):
 class Model(BaseModel):
     file_name: str
     content: str
-    openapi_object: Schema
+    openapi_object: Optional[Schema] = None
     properties: List[Property] = []
 
 
@@ -96,6 +96,6 @@ class APIConfig(BaseModel):
 
 
 class ConversionResult(BaseModel):
-    models: List[Model]
-    services: List[Service]
-    api_config: APIConfig
+    models: List[Model] = Field(default_factory=list)
+    clients: List[Model] = Field(default_factory=list)
+    exceptions: List[Model] = Field(default_factory=list)

ab_openapi_python_generator/version_detector.py

@@ -48,10 +48,7 @@ def detect_openapi_version(spec_data: Dict[str, Any]) -> OpenAPIVersion:
     elif openapi_version.startswith("3.1"):
         return "3.1"
     else:
-        raise ValueError(
-            f"Unsupported OpenAPI version: {openapi_version}. "
-            f"Only OpenAPI 3.0.x and 3.1.x are supported."
-        )
+        raise ValueError(f"Unsupported OpenAPI version: {openapi_version}. Only OpenAPI 3.0.x and 3.1.x are supported.")
 
 
 def is_openapi_30(spec_data: Dict[str, Any]) -> bool:

{ab_openapi_python_generator-2.1.4.dist-info → ab_openapi_python_generator-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ab-openapi-python-generator
-Version: 2.1.4
+Version: 2.2.0
 Summary: Openapi Python Generator
 Project-URL: Homepage, https://github.com/auth-broker/openapi-python-generator
 Project-URL: Repository, https://github.com/auth-broker/openapi-python-generator

{ab_openapi_python_generator-2.1.4.dist-info → ab_openapi_python_generator-2.2.0.dist-info}/RECORD

@@ -1,34 +1,31 @@
 ab_openapi_python_generator/__init__.py,sha256=ph2EznAu4nkHFruaG542m4TQ_xAvDlf36uKxtAkVP1s,460
 ab_openapi_python_generator/__main__.py,sha256=Vz0FsBvxQtyozKkZZFK_ag8XgJcx-5obRm44ogjD0Wk,2500
 ab_openapi_python_generator/common.py,sha256=rh6AxoWyL-jb5WbeLhiohvFUBUnevn4N7ixHPKTIiDM,1221
-ab_openapi_python_generator/generate_data.py,sha256=Av7nXE6BvsE9eHWF6eOBhPCZWWC9pi-lvksAJGB6MA8,8022
-ab_openapi_python_generator/models.py,sha256=FDnO9hKa3w05quxuQRe4bJDvRJte-uS1GwjPp4VSrBo,2199
+ab_openapi_python_generator/generate_data.py,sha256=bxu0eETzJOiucX8CP2fLWer-iYZ9MbJ0JLvCaQfbDK4,7947
+ab_openapi_python_generator/models.py,sha256=b0AyJalyZSvGyi5f5xj5ymd_s9iR09kH1UurrJDxxck,2312
 ab_openapi_python_generator/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ab_openapi_python_generator/version_detector.py,sha256=Cn7iG6_EnBdmjGmefJQ1cIBzbT28F0BeCEpoqksBGyQ,2142
+ab_openapi_python_generator/version_detector.py,sha256=PUDTpgDMHljUzxhLhMrCzHMdS3mgYQibWDiI4-vLRB4,2104
 ab_openapi_python_generator/language_converters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ab_openapi_python_generator/language_converters/python/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ab_openapi_python_generator/language_converters/python/api_config_generator.py,sha256=SSA-jac7SpP_tpzwc37Vw0VYvSfx0KlsOFeF9Bioe0g,1029
+ab_openapi_python_generator/language_converters/python/client_generator.py,sha256=LZj13DuaNZ_PD0-JafKnXQb4GUU427_N40YQuR_eLpU,18009
 ab_openapi_python_generator/language_converters/python/common.py,sha256=gZHNhVC4OwGBlmr3h9Ffz3iILO1ykva9CrqhBfeYQXU,1616
-ab_openapi_python_generator/language_converters/python/generator.py,sha256=VX8glNSu-pHo7GKYCVaP3k6JZKKGluYZq7zRZL0fDVE,1699
-ab_openapi_python_generator/language_converters/python/jinja_config.py,sha256=1xhwJAkk2BBaEzlOI-rgPWY6xjvhjrVEUqrl3rLU1uI,1144
-ab_openapi_python_generator/language_converters/python/model_generator.py,sha256=jvtMwV-SKjvXUn5sv-xULsBrsQmSj9UrK4zZ4r5n4oI,35347
-ab_openapi_python_generator/language_converters/python/service_generator.py,sha256=uVdFyAmVPfCbWwhSW7G-9Z0qEBpqpgKr8af2MbdoQhg,20107
-ab_openapi_python_generator/language_converters/python/templates/aiohttp.jinja2,sha256=Ym3-KX8JH9-V75GqkfcXVgh7rnqlkOQU5DLaNd1Wma0,2135
+ab_openapi_python_generator/language_converters/python/exception_generator.py,sha256=a4iX53W8qhQ99Tkdk2sHPCq3HvtZp5JctTbObgsRX7I,653
+ab_openapi_python_generator/language_converters/python/generator.py,sha256=g-WTVLidcpDLqYW00VufmK0_jfRAM1ZVOSAcHyLAhOU,1664
+ab_openapi_python_generator/language_converters/python/jinja_config.py,sha256=yis4AERylbqVgb2WhDWr5tqiJ02OhzkEIaDekyTt4OE,1181
+ab_openapi_python_generator/language_converters/python/model_generator.py,sha256=LDO3X1tqdVOL6U9TXGbvyQCvrLoVXh-47K5PVXJO1HE,34542
 ab_openapi_python_generator/language_converters/python/templates/alias_union.jinja2,sha256=tndnrDky4srNRyB_HnUMZFW7HtoJvEfwIFteYIu0ELc,468
-ab_openapi_python_generator/language_converters/python/templates/apiconfig.jinja2,sha256=bvYMJV6YB2NZLLcqwozISdS86XLH8J6D8o3ZpfgJCjc,1256
-ab_openapi_python_generator/language_converters/python/templates/apiconfig_pydantic_2.jinja2,sha256=_MzcHYEq9aoqSUEhZ-5SLbO80zgBeJnx5d7q3Q_usSo,1319
+ab_openapi_python_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2,sha256=UqLgyv4_Mk7LbvB9_wP4afmhWRRE-42w3mq1Sdbr8JY,2414
 ab_openapi_python_generator/language_converters/python/templates/discriminator_enum.jinja2,sha256=GJZ_ih1eURnJRPZq5P_3aKhYB5iJHymj2fpuNSdM90Y,163
 ab_openapi_python_generator/language_converters/python/templates/enum.jinja2,sha256=7dewyMLifUTe9xjCTE62deuncPiNkp7eGkIaY-IWsLo,263
-ab_openapi_python_generator/language_converters/python/templates/httpx.jinja2,sha256=zblT5_shg0vvggL0dJRz4GhGZs2bfRoeQb9YSyHLjrs,4586
+ab_openapi_python_generator/language_converters/python/templates/http_exception.jinja2,sha256=BHy48PD74aU74NGWC98iciacmGotHuWw9CaOqnCL8Kc,294
 ab_openapi_python_generator/language_converters/python/templates/models.jinja2,sha256=s5PllbxiEENsZ5_fKSh1gKMJWhcLfBdH5744nKnAZsQ,797
 ab_openapi_python_generator/language_converters/python/templates/models_pydantic_2.jinja2,sha256=o6-OlV5upoZOAVx6aQbsaigPMTCi4Uuec-oP1FNDJ60,904
-ab_openapi_python_generator/language_converters/python/templates/requests.jinja2,sha256=8R3S5M26vQol-rXHuNVYuG4qc_skC9-G8x-6AZlqTXg,2043
-ab_openapi_python_generator/language_converters/python/templates/service.jinja2,sha256=tt0Iu_JLaAlMPU73KTM7yntQjnkdvve53ShjgAGcmqY,213
+ab_openapi_python_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2,sha256=wGDXmQs1WTkMdHv-hE-UrHoWgY4hfA7vf7LujODeDRw,2390
 ab_openapi_python_generator/parsers/__init__.py,sha256=UITDIV7rp3HAA1M8kQc_9cNG6e1tS2vDa4mTKua6aMY,300
 ab_openapi_python_generator/parsers/openapi_30.py,sha256=2Hq5Vl3V4NUHKol-OO2nmt8-Fh6Lqk-hJUys8s-4UNI,1924
 ab_openapi_python_generator/parsers/openapi_31.py,sha256=jyKYAKDRkqKUPSeP6xZuM6ZCE0JjuowAe_pbm01iqWE,1924
-ab_openapi_python_generator-2.1.4.dist-info/METADATA,sha256=Ej6Sl2TNph4vKnfEixyxqRy6O1jENT7JxGSX0CXfswU,5186
-ab_openapi_python_generator-2.1.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-ab_openapi_python_generator-2.1.4.dist-info/entry_points.txt,sha256=zezbCs2qP8lSUbcjL6cN5XHoHxf9JTe15CZYH8Yuzo0,90
-ab_openapi_python_generator-2.1.4.dist-info/licenses/LICENSE,sha256=0myanGwJ2vUOZN12aN95o0My6XEysnnVlbKikYw3pHg,1070
-ab_openapi_python_generator-2.1.4.dist-info/RECORD,,
+ab_openapi_python_generator-2.2.0.dist-info/METADATA,sha256=qi60lgC1kgF1sdurWjGVach3oUXMlqmi0nic1JASRhQ,5186
+ab_openapi_python_generator-2.2.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+ab_openapi_python_generator-2.2.0.dist-info/entry_points.txt,sha256=zezbCs2qP8lSUbcjL6cN5XHoHxf9JTe15CZYH8Yuzo0,90
+ab_openapi_python_generator-2.2.0.dist-info/licenses/LICENSE,sha256=0myanGwJ2vUOZN12aN95o0My6XEysnnVlbKikYw3pHg,1070
+ab_openapi_python_generator-2.2.0.dist-info/RECORD,,

ab_openapi_python_generator/language_converters/python/api_config_generator.py

@@ -1,35 +0,0 @@
-from typing import Optional
-
-from openapi_pydantic.v3 import OpenAPI
-
-from ab_openapi_python_generator.common import PydanticVersion
-from ab_openapi_python_generator.language_converters.python.jinja_config import (
-    API_CONFIG_TEMPLATE,
-    API_CONFIG_TEMPLATE_PYDANTIC_V2,
-    create_jinja_env,
-)
-from ab_openapi_python_generator.models import APIConfig
-
-
-def generate_api_config(
-    data: OpenAPI,
-    env_token_name: Optional[str] = None,
-    pydantic_version: PydanticVersion = PydanticVersion.V2,
-) -> APIConfig:
-    """
-    Generate the API model.
-    """
-
-    template_name = (
-        API_CONFIG_TEMPLATE_PYDANTIC_V2
-        if pydantic_version == PydanticVersion.V2
-        else API_CONFIG_TEMPLATE
-    )
-    jinja_env = create_jinja_env()
-    return APIConfig(
-        file_name="api_config",
-        content=jinja_env.get_template(template_name).render(
-            env_token_name=env_token_name, **data.model_dump()
-        ),
-        base_url=data.servers[0].url if len(data.servers) > 0 else "NO SERVER",
-    )

ab_openapi_python_generator/language_converters/python/templates/aiohttp.jinja2

@@ -1,49 +0,0 @@
-async def {{ operation_id }}(api_config_override : Optional[APIConfig] = None{% if params.strip() %}, *, {{ params.rstrip(', ') }}{% endif %}) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
-    api_config = api_config_override if api_config_override else APIConfig()
-
-    base_path = api_config.base_path
-    path = f'{{ path_name }}'
-    headers = {
-    'Content-Type': 'application/json',
-    'Accept': 'application/json',
-    'Authorization': f'Bearer { api_config.get_access_token() }',
-    {{ header_params | join(',\n') | safe }}
-    }
-
-    query_params : Dict[str,Any] = {
-    {% if query_params|length > 0 %}
-        {{ query_params | join(',\n') | safe }}
-    {% endif %}
-    }
-
-    query_params = {key:value for (key,value) in query_params.items() if value is not None}
-
-    async with aiohttp.ClientSession(headers=headers) as session:
-        async with session.request(
-            '{{ method }}',
-            base_path + path,
-            params=query_params,
-    {% if body_param %}
-        {% if use_orjson %}
-            data=orjson.dumps({{ body_param }})
-        {% else %}
-            json = {{ body_param }}
-        {% endif %}
-    {% endif %}
-        ) as initial_response:
-            if initial_response.status != {{ return_type.status_code }}:
-                raise HTTPException(initial_response.status, f'{{ operation_id }} failed with status code: {initial_response.status}')
-            # Only parse JSON when a body is expected (avoid errors on 204 No Content)
-            body = None if {{ return_type.status_code }} == 204 else await initial_response.json()
-
-{% if return_type.type is none or return_type.type.converted_type is none %}
-        return None
-{% elif return_type.complex_type %}
-    {%- if return_type.list_type is none %}
-        return {{ return_type.type.converted_type }}(**body) if body is not None else {{ return_type.type.converted_type }}()
-    {%- else %}
-        return [{{ return_type.list_type }}(**item) for item in body]
-    {%- endif %}
-{% else %}
-        return body
-{% endif %}