pydantic-openapi-generator 2.2.8__py3-none-any.whl

pydantic_openapi_generator/language_converters/python/client_generator.py

@@ -0,0 +1,495 @@
+import logging
+import re
+from typing import Any, Dict, List, Literal, Optional, Tuple, Union
+
+from openapi_pydantic.v3 import (
+    Operation,
+    PathItem,
+    Reference,
+    Response,
+    Schema,
+)
+from openapi_pydantic.v3.v3_0 import (
+    MediaType as MediaType30,
+)
+
+# Import version-specific types for isinstance checks
+from openapi_pydantic.v3.v3_0 import (
+    Reference as Reference30,
+)
+from openapi_pydantic.v3.v3_0 import (
+    Response as Response30,
+)
+from openapi_pydantic.v3.v3_0 import (
+    Schema as Schema30,
+)
+from openapi_pydantic.v3.v3_0.parameter import Parameter as Parameter30
+from openapi_pydantic.v3.v3_1 import (
+    MediaType as MediaType31,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Reference as Reference31,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Response as Response31,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Schema as Schema31,
+)
+from openapi_pydantic.v3.v3_1.parameter import Parameter as Parameter31
+
+from pydantic_openapi_generator.common import PydanticVersion
+from pydantic_openapi_generator.language_converters.python import common
+from pydantic_openapi_generator.language_converters.python.jinja_config import (
+    ASYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2,
+    SYNC_CLIENT_HTTPX_TEMPLATE_PYDANTIC_V2,
+    create_jinja_env,
+)
+from pydantic_openapi_generator.language_converters.python.model_generator import (
+    type_converter,
+)
+from pydantic_openapi_generator.models import (
+    LibraryConfig,
+    Model,
+    OpReturnType,
+    ServiceOperation,
+    TypeConversion,
+)
+
+
+# Helper functions for isinstance checks across OpenAPI versions
+def is_response_type(obj) -> bool:
+    """Check if object is a Response from any OpenAPI version"""
+    return isinstance(obj, (Response30, Response31))
+
+
+def create_media_type_for_reference(
+    reference_obj: Union[Response30, Reference30, Response31, Reference31],
+):
+    """Create a MediaType wrapper for a reference object, using the correct version"""
+    # Check which version the reference object belongs to
+    if isinstance(reference_obj, Reference30):
+        return MediaType30(schema=reference_obj)  # type: ignore - pydantic issue with generics
+    elif isinstance(reference_obj, Reference31):
+        return MediaType31(schema=reference_obj)  # type: ignore - pydantic issue with generics
+    else:
+        # Fallback to v3.0 for generic Reference
+        return MediaType30(schema=reference_obj)  # type: ignore - pydantic issue with generics
+
+
+def is_media_type(obj) -> bool:
+    """Check if object is a MediaType from any OpenAPI version"""
+    return isinstance(obj, (MediaType30, MediaType31))
+
+
+def is_reference_type(obj: Any) -> bool:
+    """Check if object is a Reference type across different versions."""
+    return isinstance(obj, (Reference, Reference30, Reference31))
+
+
+def is_schema_type(obj: Any) -> bool:
+    """Check if object is a Schema from any OpenAPI version"""
+    return isinstance(obj, (Schema30, Schema31))
+
+
+def _common_suffix(a: str, b: str) -> str:
+    i = 1
+    while i <= min(len(a), len(b)) and a[-i] == b[-i]:
+        i += 1
+    return a[-(i - 1) :] if i > 1 else ""
+
+
+def _common_suffix_many(names: List[str]) -> str:
+    if not names:
+        return ""
+    suf = names[0]
+    for n in names[1:]:
+        suf = _common_suffix(suf, n)
+        if not suf:
+            break
+    return suf
+
+
+def operation_is_sse(op: Operation) -> bool:
+    """Detect if an Operation advertises Server-Sent-Events (text/event-stream) in any 2xx response."""
+    if not getattr(op, "responses", None):
+        return False
+
+    for status_code, resp in op.responses.items():
+        try:
+            if not str(status_code).startswith("2"):
+                continue
+        except Exception as e:
+            logger = logging.getLogger(__name__)
+            logger.debug("Skipping response status key; conversion failed", exc_info=e)
+            continue
+
+        # Concrete Response object
+        if is_response_type(resp):
+            content = getattr(resp, "content", None)
+            if isinstance(content, dict) and "text/event-stream" in content:
+                return True
+
+        # Reference responses could be resolved externally; skip for now
+        if is_reference_type(resp):
+            # If you need supporting $ref'ed SSE responses, resolve via components
+            pass
+
+    return False
+
+
+HTTP_OPERATIONS = ["get", "post", "put", "delete", "options", "head", "patch", "trace"]
+
+
+def generate_body_param(operation: Operation) -> Union[str, None]:
+    if operation.requestBody is None:
+        return None
+
+    # If requestBody is a $ref, it will be a Pydantic model instance in the client.
+    if isinstance(operation.requestBody, (Reference30, Reference31)):
+        return "data.model_dump(by_alias=True, exclude_none=True)"
+
+    rb_content = getattr(operation.requestBody, "content", None)
+    if rb_content is None:
+        return None  # pragma: no cover
+
+    if rb_content.get("application/json") is None:
+        return None  # pragma: no cover
+
+    media_type = rb_content.get("application/json")
+    if media_type is None:
+        return None  # pragma: no cover
+
+    mts = getattr(media_type, "media_type_schema", None)
+    if mts is None:
+        return None  # pragma: no cover
+
+    # $ref schema -> model
+    if isinstance(mts, (Reference, Reference30, Reference31)) or hasattr(mts, "ref"):
+        return "data.model_dump(by_alias=True, exclude_none=True)"
+
+    # Concrete schema
+    if isinstance(mts, (Schema, Schema30, Schema31)):
+        schema = mts
+
+        if schema.type == "array":
+            # List of models or primitives
+            return "[i.model_dump(by_alias=True, exclude_none=True) if hasattr(i, 'model_dump') else i for i in data]"
+
+        if schema.type == "object":
+            # Model or dict-like
+            return "data.model_dump(by_alias=True, exclude_none=True) if hasattr(data, 'model_dump') else data"
+
+        # Primitive (string/int/etc.)
+        return "data"
+
+    raise Exception(f"Unsupported schema type for request body: {type(mts)}")  # pragma: no cover
+
+
+def generate_params(operation: Operation) -> str:
+    def _generate_params_from_content(content: Any):
+        # Accept reference from either 3.0 or 3.1
+        if isinstance(content, (Reference, Reference30, Reference31)):
+            return f"data : {content.ref.split('/')[-1]}"  # type: ignore
+        elif isinstance(content, (Schema, Schema30, Schema31)):
+            return f"data : {type_converter(content, True).converted_type}"  # type: ignore
+        else:  # pragma: no cover
+            raise Exception(f"Unsupported request body schema type: {type(content)}")
+
+    if operation.parameters is None and operation.requestBody is None:
+        return ""
+
+    params = ""
+    default_params = ""
+    if operation.parameters is not None:
+        for param in operation.parameters:
+            if not isinstance(param, (Parameter30, Parameter31)):
+                continue  # pragma: no cover
+            converted_result = ""
+            required = False
+            param_name_cleaned = common.normalize_symbol(param.name)
+
+            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"
+                )
+                required = isinstance(param, Reference) or param.required
+
+            if required:
+                params += f"{converted_result}, "
+            else:
+                default_params += f"{converted_result}, "
+
+    operation_request_body_types = [
+        "application/json",
+        "text/plain",
+        "multipart/form-data",
+        "application/octet-stream",
+    ]
+
+    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]
+            content = rb_content.get(get_keyword)
+            if content is not None and hasattr(content, "media_type_schema"):
+                mts = getattr(content, "media_type_schema", None)
+                if isinstance(
+                    mts,
+                    (Reference, Reference30, Reference31, Schema, Schema30, Schema31),
+                ):
+                    params += f"{_generate_params_from_content(mts)}, "
+                else:  # pragma: no cover
+                    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("-", "_")
+    default_params = default_params.replace("-", "_")
+
+    return params + default_params
+
+
+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:
+        return common.normalize_symbol(f"{http_op}_{path_name}")
+    else:
+        raise Exception(
+            f"OperationId is not defined for {http_op} of path_name {path_name} --> {operation.summary}"
+        )  # pragma: no cover
+
+
+def _generate_params(operation: Operation, param_in: Literal["query", "header"] = "query"):
+    if operation.parameters is None:
+        return []
+
+    params = []
+    for param in operation.parameters:
+        if isinstance(param, (Parameter30, Parameter31)) and param.param_in == param_in:
+            param_name_cleaned = common.normalize_symbol(param.name)
+            params.append(f"{param.name!r} : {param_name_cleaned}")
+
+    return params
+
+
+def generate_query_params(operation: Operation) -> List[str]:
+    return _generate_params(operation, "query")
+
+
+def generate_header_params(operation: Operation) -> List[str]:
+    return _generate_params(operation, "header")
+
+
+def generate_return_type(operation: Operation) -> OpReturnType:
+    if operation.responses is None:
+        return OpReturnType(type=None, status_code=200, complex_type=False)
+
+    good_responses: List[Tuple[int, Union[Response, Reference]]] = [
+        (int(status_code), response)
+        for status_code, response in operation.responses.items()
+        if status_code.startswith("2")
+    ]
+    if len(good_responses) == 0:
+        return OpReturnType(type=None, status_code=200, complex_type=False)
+
+    chosen_response = good_responses[0][1]
+    media_type_schema = None
+
+    if is_response_type(chosen_response):
+        # It's a Response type, access content safely
+        if hasattr(chosen_response, "content") and chosen_response.content is not None:  # type: ignore
+            content = chosen_response.content  # type: ignore
+            # Prefer application/json, then text/event-stream, then first available
+            if isinstance(content, dict):
+                media_type_schema = (
+                    content.get("application/json")
+                    or content.get("text/event-stream")
+                    or next(iter(content.values()), None)
+                )
+            else:
+                media_type_schema = None
+    elif is_reference_type(chosen_response):
+        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)
+
+    if is_media_type(media_type_schema):
+        inner_schema = getattr(media_type_schema, "media_type_schema", None)
+        if is_reference_type(inner_schema):
+            type_conv = TypeConversion(
+                original_type=inner_schema.ref,  # type: ignore
+                converted_type=inner_schema.ref.split("/")[-1],  # type: ignore
+                import_types=[inner_schema.ref.split("/")[-1]],  # type: ignore
+            )
+            return OpReturnType(
+                type=type_conv,
+                status_code=good_responses[0][0],
+                complex_type=True,
+            )
+        elif is_schema_type(inner_schema):
+            # NEW: if this is a discriminated response union of refs, prefer a named alias
+            disc = getattr(inner_schema, "discriminator", None)
+            used = getattr(inner_schema, "oneOf", None) or getattr(inner_schema, "anyOf", None)
+            disc_key = getattr(disc, "propertyName", None) if disc is not None else None
+
+            if disc_key and used and all(is_reference_type(s) for s in used):
+                member_models = [common.normalize_symbol(s.ref.split("/")[-1]) for s in used]  # type: ignore
+                alias_name = common.normalize_symbol(_common_suffix_many(member_models)) or "Response"
+
+                type_conv = TypeConversion(
+                    original_type="discriminated_union",
+                    converted_type=alias_name,
+                    import_types=None,
+                )
+                return OpReturnType(type=type_conv, status_code=good_responses[0][0], complex_type=True)
+
+            converted_result = type_converter(inner_schema, True)  # type: ignore
+            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}")
+            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),
+                list_type=list_type,
+            )
+        else:  # pragma: no cover
+            raise Exception("Unknown media type schema type")
+    elif media_type_schema is None:
+        return OpReturnType(
+            type=None,
+            status_code=good_responses[0][0],
+            complex_type=False,
+        )
+    else:
+        raise Exception("Unknown media type schema type")  # pragma: no cover
+
+
+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]:
+    """
+    Generate two client modules:
+      - sync_client.py (SyncClient)
+      - async_client.py (AsyncClient)
+    """
+    jinja_env = create_jinja_env()
+
+    service_ops: List[ServiceOperation] = []
+
+    def _generate_service_operation(
+        op: Operation, path_obj: PathItem, path_name: str, http_operation: str, async_type: bool
+    ) -> ServiceOperation:
+        path_level_params = []
+        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:
+                    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 op.parameters is None:
+                        op.parameters = []  # type: ignore
+                    op.parameters.append(p)  # type: ignore
+
+        params = generate_params(op)
+        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
+
+        operation_id = generate_operation_id(op, http_operation, path_name)
+        query_params = generate_query_params(op)
+        header_params = generate_header_params(op)
+        return_type = generate_return_type(op)
+        body_param = generate_body_param(op)
+
+        so = ServiceOperation(
+            params=params,
+            operation_id=operation_id,
+            query_params=query_params,
+            header_params=header_params,
+            return_type=return_type,
+            operation=op,
+            pathItem=path_obj,
+            content="",
+            async_client=async_type,
+            body_param=body_param,
+            path_name=path_name,
+            method=http_operation,
+            is_sse=operation_is_sse(op),
+            use_orjson=common.get_use_orjson(),
+        )
+
+        return so
+
+    for path_name, path in paths.items():
+        clean_path_name = clean_up_path_name(path_name)
+        for http_operation in HTTP_OPERATIONS:
+            op = getattr(path, http_operation)
+            if op is None:
+                continue
+
+            if library_config.include_sync:
+                service_ops.append(_generate_service_operation(op, path, clean_path_name, http_operation, False))
+            if library_config.include_async:
+                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 clients

pydantic_openapi_generator/language_converters/python/common.py

@@ -0,0 +1,58 @@
+import keyword
+import re
+from typing import Optional
+
+_use_orjson: bool = False
+_custom_template_path: Optional[str] = None
+_symbol_ascii_strip_re = re.compile(r"[^A-Za-z0-9_]")
+
+
+def set_use_orjson(value: bool) -> None:
+    """
+    Set the value of the global variable _use_orjson.
+    :param value: value of the variable
+    """
+    global _use_orjson
+    _use_orjson = value
+
+
+def get_use_orjson() -> bool:
+    """
+    Get the value of the global variable _use_orjson.
+    :return: value of the variable
+    """
+    global _use_orjson
+    return _use_orjson
+
+
+def set_custom_template_path(value: Optional[str]) -> None:
+    """
+    Set the value of the global variable _custom_template_path.
+    :param value: value of the variable
+    """
+    global _custom_template_path
+    _custom_template_path = value
+
+
+def get_custom_template_path() -> Optional[str]:
+    """
+    Get the value of the global variable _custom_template_path.
+    :return: value of the variable
+    """
+    global _custom_template_path
+    return _custom_template_path
+
+
+def normalize_symbol(symbol: str) -> str:
+    """
+    Remove invalid characters & keywords in Python symbol names
+    :param symbol: name of the identifier
+    :return: normalized identifier name
+    """
+    symbol = symbol.replace("-", "_").replace(" ", "_")
+    normalized_symbol = _symbol_ascii_strip_re.sub("", symbol)
+    if normalized_symbol in keyword.kwlist:
+        normalized_symbol = normalized_symbol + "_"
+    if len(normalized_symbol) > 0 and normalized_symbol[0].isnumeric():
+        normalized_symbol = "_" + normalized_symbol
+    return normalized_symbol

pydantic_openapi_generator/language_converters/python/exception_generator.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+from pydantic_openapi_generator.language_converters.python.jinja_config import (
+    HTTP_EXCEPTION_TEMPLATE,
+    create_jinja_env,
+)
+from pydantic_openapi_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]

pydantic_openapi_generator/language_converters/python/generator.py

@@ -0,0 +1,61 @@
+from typing import Optional, Union
+
+from openapi_pydantic.v3.v3_0 import OpenAPI as OpenAPI30
+from openapi_pydantic.v3.v3_1 import OpenAPI as OpenAPI31
+
+from pydantic_openapi_generator.common import PydanticVersion
+from pydantic_openapi_generator.language_converters.python import common
+from pydantic_openapi_generator.language_converters.python.client_generator import (
+    generate_clients,
+)
+from pydantic_openapi_generator.language_converters.python.exception_generator import (
+    generate_exceptions,
+)
+from pydantic_openapi_generator.language_converters.python.model_generator import (
+    generate_models,
+    generate_response_union_alias_models,
+)
+from pydantic_openapi_generator.models import ConversionResult, LibraryConfig
+
+# Type alias for both OpenAPI versions
+OpenAPISpec = Union[OpenAPI30, OpenAPI31]
+
+
+def generator(
+    data: OpenAPISpec,
+    library_config: LibraryConfig,
+    env_token_name: Optional[str] = None,
+    use_orjson: bool = False,
+    custom_template_path: Optional[str] = None,
+    pydantic_version: PydanticVersion = PydanticVersion.V2,
+) -> ConversionResult:
+    """
+    Generate Python code from an OpenAPI 3.0+ specification.
+    """
+
+    common.set_use_orjson(use_orjson)
+    common.set_custom_template_path(custom_template_path)
+
+    if data.components is not None:
+        models = generate_models(data.components, pydantic_version)
+    else:
+        models = []
+
+    # Generate response union alias models (e.g. AuthorizeResponse) from paths
+    # so client return types that reference those aliases have corresponding
+    # model modules available in the output.
+    if data.paths is not None:
+        resp_alias_models = generate_response_union_alias_models(data.paths, pydantic_version)
+        if resp_alias_models:
+            models.extend(resp_alias_models)
+
+    if data.paths is not None:
+        clients = generate_clients(data, data.paths, library_config, env_token_name, pydantic_version)
+    else:
+        clients = []
+
+    return ConversionResult(
+        models=models,
+        clients=clients,
+        exceptions=generate_exceptions(),
+    )

pydantic_openapi_generator/language_converters/python/jinja_config.py

@@ -0,0 +1,38 @@
+from pathlib import Path
+
+from jinja2 import ChoiceLoader, Environment, FileSystemLoader, select_autoescape
+
+from . import common
+
+ENUM_TEMPLATE = "enum.jinja2"
+MODELS_TEMPLATE = "models.jinja2"
+MODELS_TEMPLATE_PYDANTIC_V2 = "models_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"
+
+
+def create_jinja_env():
+    custom_template_path = common.get_custom_template_path()
+    environment = Environment(
+        loader=(
+            ChoiceLoader(
+                [
+                    FileSystemLoader(custom_template_path),
+                    FileSystemLoader(TEMPLATE_PATH),
+                ]
+            )
+            if custom_template_path is not None
+            else FileSystemLoader(TEMPLATE_PATH)
+        ),
+        autoescape=select_autoescape(default_for_string=False),
+        trim_blocks=True,
+        lstrip_blocks=True,
+    )
+
+    environment.filters["normalize_symbol"] = common.normalize_symbol
+
+    return environment