ab-openapi-python-generator 2.1.4__tar.gz → 2.2.0__tar.gz

{ab_openapi_python_generator-2.1.4 → ab_openapi_python_generator-2.2.0}/PKG-INFO

@@ -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 → ab_openapi_python_generator-2.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ab-openapi-python-generator"
-version = "2.1.4"
+version = "2.2.0"
 description = "Openapi Python Generator"
 authors = [
     { name = "Marco Müllner", email = "muellnermarco@gmail.com" },

{ab_openapi_python_generator-2.1.4 → ab_openapi_python_generator-2.2.0}/src/ab_openapi_python_generator/generate_data.py

@@ -12,7 +12,6 @@ from httpx import ConnectError, ConnectTimeout
 from pydantic import ValidationError
 
 from .common import FormatOptions, Formatter, HTTPLibrary, PydanticVersion
-from .language_converters.python.jinja_config import SERVICE_TEMPLATE, create_jinja_env
 from .models import ConversionResult
 from .parsers import (
     generate_code_3_0,
@@ -35,9 +34,7 @@ def write_code(path: Path, content: str, formatter: Formatter) -> None:
     elif formatter == Formatter.NONE:
         formatted_contend = content
     else:
-        raise NotImplementedError(
-            f"Missing implementation for formatter {formatter!r}."
-        )
+        raise NotImplementedError(f"Missing implementation for formatter {formatter!r}.")
     with open(path, "w") as f:
         f.write(formatted_contend)
 
@@ -74,9 +71,7 @@ def get_open_api(source: Union[str, Path]):
     """
     try:
         # Handle remote files
-        if not isinstance(source, Path) and (
-            source.startswith("http://") or source.startswith("https://")
-        ):
+        if not isinstance(source, Path) and (source.startswith("http://") or source.startswith("https://")):
             content = httpx.get(source).text
             # Try JSON first, then YAML for remote files
             try:
@@ -96,9 +91,7 @@ def get_open_api(source: Union[str, Path]):
                     try:
                         data = yaml.safe_load(file_content)
                     except yaml.YAMLError as e:
-                        click.echo(
-                            f"File {source} is neither a valid JSON nor YAML file: {str(e)}"
-                        )
+                        click.echo(f"File {source} is neither a valid JSON nor YAML file: {str(e)}")
                         raise
 
         # Detect version and parse with appropriate parser
@@ -110,16 +103,12 @@ def get_open_api(source: Union[str, Path]):
             openapi_obj = parse_openapi_3_1(data)  # type: ignore[assignment]
         else:
             # Unsupported version detected (version detection already limited to 3.0 / 3.1)
-            raise ValueError(
-                f"Unsupported OpenAPI version: {version}. Only 3.0.x and 3.1.x are supported."
-            )
+            raise ValueError(f"Unsupported OpenAPI version: {version}. Only 3.0.x and 3.1.x are supported.")
 
         return openapi_obj, version
 
     except FileNotFoundError:
-        click.echo(
-            f"File {source} not found. Please make sure to pass the path to the OpenAPI specification."
-        )
+        click.echo(f"File {source} not found. Please make sure to pass the path to the OpenAPI specification.")
         raise
     except (ConnectError, ConnectTimeout):
         click.echo(f"Could not connect to {source}.")
@@ -129,70 +118,81 @@ def get_open_api(source: Union[str, Path]):
         raise
 
 
-def write_data(
-    data: ConversionResult, output: Union[str, Path], formatter: Formatter
-) -> None:
-    """
-    This function will firstly create the folder structure of output, if it doesn't exist. Then it will create the
-    models from data.models into the models sub module of the output folder. After this, the services will be created
-    into the services sub module of the output folder.
-    :param data: The data to write.
-    :param output: The path to the output folder.
-    :param formatter: The formatter applied to the code written.
+def write_data(data: ConversionResult, output: Union[str, Path], formatter: Formatter) -> None:
     """
+    Write generated code to disk.
 
-    # Create the folder structure of the output folder.
-    Path(output).mkdir(parents=True, exist_ok=True)
+    Creates:
+      - models/ (and models/__init__.py)
+      - clients/ (and clients/__init__.py)
+      - exceptions.py (package root, if present)
+      - __init__.py (package root)
+    """
+    out = Path(output)
+    out.mkdir(parents=True, exist_ok=True)
 
-    # Create the models module.
-    models_path = Path(output) / "models"
+    # ----------------------------
+    # models/
+    # ----------------------------
+    models_path = out / "models"
     models_path.mkdir(parents=True, exist_ok=True)
 
-    # Create the services module.
-    services_path = Path(output) / "services"
-    services_path.mkdir(parents=True, exist_ok=True)
-
-    files: List[str] = []
-
-    # Write the models.
+    model_files: List[str] = []
     for model in data.models:
-        files.append(model.file_name)
+        model_files.append(model.file_name)
         write_code(models_path / f"{model.file_name}.py", model.content, formatter)
 
-    # Create models.__init__.py file containing imports to all models.
     write_code(
         models_path / "__init__.py",
-        "\n".join([f"from .{file} import *" for file in files]),
+        "\n".join([f"from .{f} import *" for f in model_files]) + ("\n" if model_files else ""),
         formatter,
     )
 
-    files = []
-
-    # Write the services.
-    jinja_env = create_jinja_env()
-    for service in data.services:
-        if len(service.operations) == 0:
-            continue
-        files.append(service.file_name)
-        write_code(
-            services_path / f"{service.file_name}.py",
-            jinja_env.get_template(SERVICE_TEMPLATE).render(**service.model_dump()),
-            formatter,
-        )
+    # ----------------------------
+    # clients/
+    # ----------------------------
+    clients_path = out / "clients"
+    clients_path.mkdir(parents=True, exist_ok=True)
+
+    client_files: List[str] = []
+    for client in data.clients:
+        client_files.append(client.file_name)
+        write_code(clients_path / f"{client.file_name}.py", client.content, formatter)
+
+    write_code(
+        clients_path / "__init__.py",
+        "\n".join([f"from .{f} import *" for f in client_files]) + ("\n" if client_files else ""),
+        formatter,
+    )
 
-    # Create services.__init__.py file containing imports to all services.
-    write_code(services_path / "__init__.py", "", formatter)
+    # ----------------------------
+    # exceptions/
+    # ----------------------------
+    exceptions_path = out / "exceptions"
+    exceptions_path.mkdir(parents=True, exist_ok=True)
 
-    # Write the api_config.py file.
-    write_code(Path(output) / "api_config.py", data.api_config.content, formatter)
+    exception_files: List[str] = []
+    for ex in data.exceptions:
+        exception_files.append(ex.file_name)
+        write_code(exceptions_path / f"{ex.file_name}.py", ex.content, formatter)
 
-    # Write the __init__.py file.
     write_code(
-        Path(output) / "__init__.py",
-        "from .models import *\nfrom .services import *\nfrom .api_config import *",
+        exceptions_path / "__init__.py",
+        "\n".join([f"from .{f} import *" for f in exception_files]) + ("\n" if exception_files else ""),
         formatter,
     )
 
+    # ----------------------------
+    # package __init__.py (root)
+    # ----------------------------
+    init_lines: List[str] = [
+        "from .models import *",
+        "from .clients import *",
+        "from .exceptions import *",
+    ]
+
+    write_code(out / "__init__.py", "\n".join(init_lines) + "\n", formatter)
+
 
 def generate_data(
     source: Union[str, Path],

ab_openapi_python_generator-2.1.4/src/ab_openapi_python_generator/language_converters/python/service_generator.py → ab_openapi_python_generator-2.2.0/src/ab_openapi_python_generator/language_converters/python/client_generator.py

@@ -1,7 +1,6 @@
 import re
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
-import click
 from openapi_pydantic.v3 import (
     Operation,
     PathItem,
@@ -38,9 +37,11 @@ from openapi_pydantic.v3.v3_1 import (
 )
 from openapi_pydantic.v3.v3_1.parameter import Parameter as Parameter31
 
+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.common import normalize_symbol
 from ab_openapi_python_generator.language_converters.python.jinja_config import (
+    ASYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2,
+    SYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2,
     create_jinja_env,
 )
 from ab_openapi_python_generator.language_converters.python.model_generator import (
@@ -48,8 +49,8 @@ from ab_openapi_python_generator.language_converters.python.model_generator impo
 )
 from ab_openapi_python_generator.models import (
     LibraryConfig,
+    Model,
     OpReturnType,
-    Service,
     ServiceOperation,
     TypeConversion,
 )
@@ -123,9 +124,7 @@ def generate_body_param(operation: Operation) -> Union[str, None]:
     if operation.requestBody is None:
         return None
     else:
-        if isinstance(operation.requestBody, Reference30) or isinstance(
-            operation.requestBody, Reference31
-        ):
+        if isinstance(operation.requestBody, Reference30) or isinstance(operation.requestBody, Reference31):
             return "data.dict()"
 
         if operation.requestBody.content is None:
@@ -139,9 +138,7 @@ def generate_body_param(operation: Operation) -> Union[str, None]:
         if media_type is None:
             return None  # pragma: no cover
 
-        if isinstance(
-            media_type.media_type_schema, (Reference, Reference30, Reference31)
-        ):
+        if isinstance(media_type.media_type_schema, (Reference, Reference30, Reference31)):
             return "data.dict()"
         elif hasattr(media_type.media_type_schema, "ref"):
             # Handle Reference objects from different OpenAPI versions
@@ -153,9 +150,7 @@ def generate_body_param(operation: Operation) -> Union[str, None]:
             elif schema.type == "object":
                 return "data"
             else:
-                raise Exception(
-                    f"Unsupported schema type for request body: {schema.type}"
-                )  # pragma: no cover
+                raise Exception(f"Unsupported schema type for request body: {schema.type}")  # pragma: no cover
         else:
             raise Exception(
                 f"Unsupported schema type for request body: {type(media_type.media_type_schema)}"
@@ -185,26 +180,17 @@ def generate_params(operation: Operation) -> str:
             required = False
             param_name_cleaned = common.normalize_symbol(param.name)
 
-            if isinstance(param.param_schema, Schema30) or isinstance(
-                param.param_schema, Schema31
-            ):
+            if isinstance(param.param_schema, Schema30) or isinstance(param.param_schema, Schema31):
                 converted_result = (
                     f"{param_name_cleaned} : {type_converter(param.param_schema, param.required).converted_type}"
                     + ("" if param.required else " = None")
                 )
                 required = param.required
-            elif isinstance(param.param_schema, Reference30) or isinstance(
-                param.param_schema, Reference31
-            ):
-                converted_result = (
-                    f"{param_name_cleaned} : {param.param_schema.ref.split('/')[-1] }"
-                    + (
-                        ""
-                        if isinstance(param, Reference30)
-                        or isinstance(param, Reference31)
-                        or param.required
-                        else " = None"
-                    )
+            elif isinstance(param.param_schema, Reference30) or isinstance(param.param_schema, Reference31):
+                converted_result = f"{param_name_cleaned} : {param.param_schema.ref.split('/')[-1]}" + (
+                    ""
+                    if isinstance(param, Reference30) or isinstance(param, Reference31) or param.required
+                    else " = None"
                 )
                 required = isinstance(param, Reference) or param.required
 
@@ -220,17 +206,11 @@ def generate_params(operation: Operation) -> str:
         "application/octet-stream",
     ]
 
-    if operation.requestBody is not None and not is_reference_type(
-        operation.requestBody
-    ):
+    if operation.requestBody is not None and not is_reference_type(operation.requestBody):
         # Safe access only if it's a concrete RequestBody object
         rb_content = getattr(operation.requestBody, "content", None)
-        if isinstance(rb_content, dict) and any(
-            rb_content.get(i) is not None for i in operation_request_body_types
-        ):
-            get_keyword = [
-                i for i in operation_request_body_types if rb_content.get(i)
-            ][0]
+        if isinstance(rb_content, dict) and any(rb_content.get(i) is not None for i in operation_request_body_types):
+            get_keyword = [i for i in operation_request_body_types if rb_content.get(i)][0]
             content = rb_content.get(get_keyword)
             if content is not None and hasattr(content, "media_type_schema"):
                 mts = getattr(content, "media_type_schema", None)
@@ -240,9 +220,7 @@ def generate_params(operation: Operation) -> str:
                 ):
                     params += f"{_generate_params_from_content(mts)}, "
                 else:  # pragma: no cover
-                    raise Exception(
-                        f"Unsupported media type schema for {str(operation)}: {type(mts)}"
-                    )
+                    raise Exception(f"Unsupported media type schema for {str(operation)}: {type(mts)}")
         # else: silently ignore unsupported body shapes (could extend later)
     # Replace - with _ in params
     params = params.replace("-", "_")
@@ -251,9 +229,7 @@ def generate_params(operation: Operation) -> str:
     return params + default_params
 
 
-def generate_operation_id(
-    operation: Operation, http_op: str, path_name: Optional[str] = None
-) -> str:
+def generate_operation_id(operation: Operation, http_op: str, path_name: Optional[str] = None) -> str:
     if operation.operationId is not None:
         return common.normalize_symbol(operation.operationId)
     elif path_name is not None:
@@ -264,9 +240,7 @@ def generate_operation_id(
         )  # pragma: no cover
 
 
-def _generate_params(
-    operation: Operation, param_in: Literal["query", "header"] = "query"
-):
+def _generate_params(operation: Operation, param_in: Literal["query", "header"] = "query"):
     if operation.parameters is None:
         return []
 
@@ -319,9 +293,7 @@ def generate_return_type(operation: Operation) -> OpReturnType:
         media_type_schema = create_media_type_for_reference(chosen_response)
 
     if media_type_schema is None:
-        return OpReturnType(
-            type=None, status_code=good_responses[0][0], complex_type=False
-        )
+        return OpReturnType(type=None, status_code=good_responses[0][0], complex_type=False)
 
     if is_media_type(media_type_schema):
         inner_schema = getattr(media_type_schema, "media_type_schema", None)
@@ -338,25 +310,18 @@ def generate_return_type(operation: Operation) -> OpReturnType:
             )
         elif is_schema_type(inner_schema):
             converted_result = type_converter(inner_schema, True)  # type: ignore
-            if "array" in converted_result.original_type and isinstance(
-                converted_result.import_types, list
-            ):
+            if "array" in converted_result.original_type and isinstance(converted_result.import_types, list):
                 matched = re.findall(r"List\[(.+)\]", converted_result.converted_type)
                 if len(matched) > 0:
                     list_type = matched[0]
                 else:  # pragma: no cover
-                    raise Exception(
-                        f"Unable to parse list type from {converted_result.converted_type}"
-                    )
+                    raise Exception(f"Unable to parse list type from {converted_result.converted_type}")
             else:
                 list_type = None
             return OpReturnType(
                 type=converted_result,
                 status_code=good_responses[0][0],
-                complex_type=bool(
-                    converted_result.import_types
-                    and len(converted_result.import_types) > 0
-                ),
+                complex_type=bool(converted_result.import_types and len(converted_result.import_types) > 0),
                 list_type=list_type,
             )
         else:  # pragma: no cover
@@ -371,63 +336,62 @@ def generate_return_type(operation: Operation) -> OpReturnType:
         raise Exception("Unknown media type schema type")  # pragma: no cover
 
 
-def generate_services(
-    paths: Dict[str, PathItem], library_config: LibraryConfig
-) -> List[Service]:
+def clean_up_path_name(path_name: str) -> str:
+    # Clean up path name: only replace dashes inside curly brackets for f-string compatibility, keep other dashes
+    def _replace_bracket_dashes(match):
+        return "{" + match.group(1).replace("-", "_") + "}"
+
+    return re.sub(r"\{([^}/]+)\}", _replace_bracket_dashes, path_name)
+
+
+def generate_clients(
+    openapi: Any,
+    paths: Dict[str, PathItem],
+    library_config: LibraryConfig,
+    env_token_name: Optional[str],
+    pydantic_version: PydanticVersion,
+) -> List[Model]:
     """
-    Generates services from a paths object.
-    :param paths: paths object to be converted
-    :return: List of services
+    Generate two client modules:
+      - sync_client.py (SyncClient)
+      - async_client.py (AsyncClient)
     """
     jinja_env = create_jinja_env()
 
-    def generate_service_operation(
-        op: Operation, path_name: str, async_type: bool
+    service_ops: List[ServiceOperation] = []
+
+    def _generate_service_operation(
+        op: Operation, path_obj: PathItem, path_name: str, http_operation: str, async_type: bool
     ) -> ServiceOperation:
-        # Merge path-level parameters (always required by spec) into the
-        # operation-level parameters so they get turned into function args.
         try:
             path_level_params = []
-            if hasattr(path, "parameters") and path.parameters is not None:  # type: ignore
-                path_level_params = [p for p in path.parameters if p is not None]  # type: ignore
+            if hasattr(path_obj, "parameters") and path_obj.parameters is not None:
+                path_level_params = [p for p in path_obj.parameters if p is not None]
             if path_level_params:
                 existing_names = set()
                 if op.parameters is not None:
-                    for p in op.parameters:  # type: ignore
+                    for p in op.parameters:
                         if isinstance(p, (Parameter30, Parameter31)):
                             existing_names.add(p.name)
                 for p in path_level_params:
-                    if (
-                        isinstance(p, (Parameter30, Parameter31))
-                        and p.name not in existing_names
-                    ):
+                    if isinstance(p, (Parameter30, Parameter31)) and p.name not in existing_names:
                         if op.parameters is None:
                             op.parameters = []  # type: ignore
                         op.parameters.append(p)  # type: ignore
-        except Exception:  # pragma: no cover
-            print(
-                f"Error merging path-level parameters for {path_name}"
-            )  # pragma: no cover
+        except Exception:
             pass
 
         params = generate_params(op)
-        # Fallback: ensure all {placeholders} in path are present as function params
         try:
-            placeholder_names = [
-                m.group(1) for m in re.finditer(r"\{([^}/]+)\}", path_name)
-            ]
-            existing_param_names = {
-                p.split(":")[0].strip() for p in params.split(",") if ":" in p
-            }
+            placeholder_names = [m.group(1) for m in re.finditer(r"\{([^}/]+)\}", path_name)]
+            existing_param_names = {p.split(":")[0].strip() for p in params.split(",") if ":" in p}
             for ph in placeholder_names:
                 norm_ph = common.normalize_symbol(ph)
                 if norm_ph not in existing_param_names and norm_ph:
                     params = f"{norm_ph}: Any, " + params
-        except Exception:  # pragma: no cover
-            print(
-                f"Error ensuring path placeholders in params for {path_name}"
-            )  # pragma: no cover
+        except Exception:
             pass
+
         operation_id = generate_operation_id(op, http_operation, path_name)
         query_params = generate_query_params(op)
         header_params = generate_header_params(op)
@@ -441,7 +405,7 @@ def generate_services(
             header_params=header_params,
             return_type=return_type,
             operation=op,
-            pathItem=path,
+            pathItem=path_obj,
             content="",
             async_client=async_type,
             body_param=body_param,
@@ -451,90 +415,42 @@ def generate_services(
             use_orjson=common.get_use_orjson(),
         )
 
-        so.content = jinja_env.get_template(library_config.template_name).render(
-            **so.model_dump()
-        )
-
-        if op.tags is not None and len(op.tags) > 0:
-            so.tag = normalize_symbol(op.tags[0])
-
-        try:
-            compile(so.content, "<string>", "exec")
-        except SyntaxError as e:  # pragma: no cover
-            click.echo(f"Error in service {so.operation_id}: {e}")  # pragma: no cover
-
         return so
 
-    services = []
-    service_ops = []
     for path_name, path in paths.items():
         clean_path_name = clean_up_path_name(path_name)
         for http_operation in HTTP_OPERATIONS:
-            op = path.__getattribute__(http_operation)
+            op = getattr(path, http_operation)
             if op is None:
                 continue
 
             if library_config.include_sync:
-                sync_so = generate_service_operation(op, clean_path_name, False)
-                service_ops.append(sync_so)
-
+                service_ops.append(_generate_service_operation(op, path, clean_path_name, http_operation, False))
             if library_config.include_async:
-                async_so = generate_service_operation(op, clean_path_name, True)
-                service_ops.append(async_so)
-
-    # Ensure every operation has a tag; fallback to "default" for untagged operations
-    for so in service_ops:
-        if not so.tag:
-            so.tag = "default"
-
-    tags = list({so.tag for so in service_ops})
-
-    for tag in tags:
-        services.append(
-            Service(
-                file_name=f"{tag}_service",
-                operations=[
-                    so for so in service_ops if so.tag == tag and not so.async_client
-                ],
-                content="\n".join(
-                    [
-                        so.content
-                        for so in service_ops
-                        if so.tag == tag and not so.async_client
-                    ]
-                ),
-                async_client=False,
-                library_import=library_config.library_name,
-                use_orjson=common.get_use_orjson(),
-            )
-        )
-
-    for tag in tags:
-        services.append(
-            Service(
-                file_name=f"async_{tag}_service",
-                operations=[
-                    so for so in service_ops if so.tag == tag and so.async_client
-                ],
-                content="\n".join(
-                    [
-                        so.content
-                        for so in service_ops
-                        if so.tag == tag and so.async_client
-                    ]
-                ),
-                async_client=True,
-                library_import=library_config.library_name,
-                use_orjson=common.get_use_orjson(),
-            )
-        )
-
-    return services
-
-
-def clean_up_path_name(path_name: str) -> str:
-    # Clean up path name: only replace dashes inside curly brackets for f-string compatibility, keep other dashes
-    def _replace_bracket_dashes(match):
-        return "{" + match.group(1).replace("-", "_") + "}"
+                service_ops.append(_generate_service_operation(op, path, clean_path_name, http_operation, True))
+
+    sync_ops = [so for so in service_ops if not so.async_client]
+    async_ops = [so for so in service_ops if so.async_client]
+
+    openapi_dump = openapi.model_dump() if hasattr(openapi, "model_dump") else {}
+
+    sync_content = jinja_env.get_template(SYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2).render(
+        **openapi_dump,
+        env_token_name=env_token_name,
+        operations=[so.model_dump() for so in sync_ops],
+    )
+    async_content = jinja_env.get_template(ASYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2).render(
+        **openapi_dump,
+        env_token_name=env_token_name,
+        operations=[so.model_dump() for so in async_ops],
+    )
+
+    compile(sync_content, "<string>", "exec")
+    compile(async_content, "<string>", "exec")
+
+    clients: List[Model] = [
+        Model(file_name="sync_client", content=sync_content, openapi_object={}, properties=[]),
+        Model(file_name="async_client", content=async_content, openapi_object={}, properties=[]),
+    ]
 
-    return re.sub(r"\{([^}/]+)\}", _replace_bracket_dashes, path_name)
+    return clients

ab_openapi_python_generator-2.2.0/src/ab_openapi_python_generator/language_converters/python/exception_generator.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from ab_openapi_python_generator.language_converters.python.jinja_config import (
+    HTTP_EXCEPTION_TEMPLATE,
+    create_jinja_env,
+)
+from ab_openapi_python_generator.models import Model
+
+
+def generate_exceptions() -> list[Model]:
+    """
+    Generate shared exception modules (package-local support code).
+    """
+    jinja_env = create_jinja_env()
+
+    http_exception = Model(
+        file_name="http_exception",
+        content=jinja_env.get_template(HTTP_EXCEPTION_TEMPLATE).render(),
+        openapi_object=None,  # Model.openapi_object is optional now
+        properties=[],
+    )
+
+    return [http_exception]