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

pydantic_openapi_generator/language_converters/python/templates/alias_union.jinja2

@@ -0,0 +1,17 @@
+{# Renders ONE standalone python module that defines a named Union/Annotated alias #}
+{% if discriminator_key -%}
+from typing import Annotated, Union
+from pydantic import Field
+{% else -%}
+from typing import Union
+{% endif %}
+
+{% for imp in member_imports -%}
+{{ imp }}
+{% endfor %}
+
+{% if discriminator_key -%}
+{{ alias_name }} = Annotated[{{ union_type }}, Field(discriminator="{{ discriminator_key }}")]
+{% else -%}
+{{ alias_name }} = {{ union_type }}
+{% endif -%}

pydantic_openapi_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -0,0 +1,151 @@
+{% if env_token_name is not none %}import os{% endif %}
+
+from __future__ import annotations
+
+from collections.abc import AsyncGenerator
+from typing import Any, Dict, Optional, Union
+import json
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+from ..models import *
+from ..exceptions import HTTPException
+
+{% set _base_url = servers[0].url if servers|length > 0 else "/" %}
+
+
+class AsyncClient(BaseModel):
+    model_config = {"validate_assignment": True}
+
+    base_url: str = "{{ _base_url }}"
+    verify: Union[bool, str] = True
+{% if env_token_name is none %}
+    access_token: Optional[str] = None
+{% endif %}
+
+    async 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 %}
+
+    async 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 %}) -> {%- if op.is_sse -%}
+AsyncGenerator[str | dict[str, Any], None]
+{%- else -%}
+{%- if op.return_type.type is none or op.return_type.type.converted_type is none -%}None
+{%- elif op.return_type.list_type is not none -%}list[{{ op.return_type.list_type }}]
+{%- else -%}{{ op.return_type.type.converted_type }}
+{%- endif -%}
+{%- endif -%}:
+        base_url = self.base_url
+        path = f"{{ op.path_name }}"
+
+        headers = {
+{% if op.body_param %}
+            "Content-Type": "application/json",
+{% endif %}
+{% if op.is_sse %}
+            "Accept": "text/event-stream",
+{% else %}
+            "Accept": "application/json",
+{% endif %}
+        }
+
+        _token = await self.get_access_token()
+        if _token:
+            headers["Authorization"] = f"Bearer {_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}
+
+{% if op.is_sse %}
+        async with httpx.AsyncClient(base_url=base_url, verify=self.verify) as client:
+            async with client.stream(
+                "{{ op.method }}",
+                httpx.URL(path),
+                headers=headers,
+                params=query_params,
+{% if op.body_param %}
+                json={{ op.body_param }},
+{% endif %}
+            ) as response:
+                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}",
+                    )
+
+                async for line in response.aiter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data:"):
+                        payload = line[len("data:"):].strip()
+                        if not payload:
+                            continue
+                        if payload == "[DONE]":
+                            break
+                        try:
+                            obj = json.loads(payload)
+                            if isinstance(obj, dict):
+                                yield obj
+                            else:
+                                yield payload
+                        except Exception:
+                            yield payload
+                    else:
+                        # Non-data lines: yield as raw text for debugging/visibility
+                        yield line
+{% else %}
+        async with httpx.AsyncClient(base_url=base_url, 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()
+
+{% if op.return_type.type is none or op.return_type.type.converted_type is none %}
+        return None
+{% elif op.return_type.complex_type %}
+{% if op.return_type.list_type is none %}
+        return TypeAdapter({{ op.return_type.type.converted_type }}).validate_python(body)
+{% else %}
+        return TypeAdapter(list[{{ op.return_type.list_type }}]).validate_python(body)
+{% endif %}
+{% else %}
+        return body
+{% endif %}
+{% endif %}
+
+{% endfor %}

pydantic_openapi_generator/language_converters/python/templates/discriminator_enum.jinja2

@@ -0,0 +1,7 @@
+from enum import Enum
+
+
+class {{ enum_name }}(str, Enum):
+{% for member_name, member_value in members %}
+    {{ member_name }} = "{{ member_value }}"
+{% endfor %}

pydantic_openapi_generator/language_converters/python/templates/enum.jinja2

@@ -0,0 +1,11 @@
+from enum import Enum
+
+class {{ name }}(str, Enum):
+    {% for enumItemIdent, enumItem in enum %}
+
+    {% if enumItem is string %}
+    {{ enumItemIdent }} = '{{ enumItem }}'
+    {% else %}
+    {{ enumItemIdent }} = {{ enumItem }}
+    {% endif %}
+    {% endfor %}

pydantic_openapi_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}"

pydantic_openapi_generator/language_converters/python/templates/models.jinja2

@@ -0,0 +1,24 @@
+from typing import *
+from pydantic import BaseModel, Field
+{%  for property in properties %}
+{% if property.type.import_types is not none %}
+{% for import_type in property.type.import_types %}
+{{ import_type }}
+{% endfor %}
+{% endif %}
+{% endfor %}
+
+class {{ schema_name }}(BaseModel):
+    """
+    {% if schema.title %}{{ schema.title }}{% else %}{{ schema_name }}{% endif %} model
+    {% if schema.description %}
+    {{ schema.description }}
+    {% endif %}
+    {% if parent_comment %}
+    {{ parent_comment }}
+    {% endif %}
+    """
+    {% for property in properties %}
+
+    {{ property.name | normalize_symbol }} : {{ property.type.converted_type | safe }} = Field(alias="{{ property.name }}"{% if property.default is not none %}, default = {{ property.default }}{% endif %})
+    {% endfor %}

pydantic_openapi_generator/language_converters/python/templates/models_pydantic_2.jinja2

@@ -0,0 +1,28 @@
+from typing import *
+from pydantic import BaseModel, Field
+{% for property in properties %}
+{% if property.type.import_types is not none %}
+{% for import_type in property.type.import_types %}
+{{ import_type }}
+{% endfor %}
+{% endif %}
+{% endfor %}
+
+class {{ schema_name }}(BaseModel):
+    """
+    {% if schema.title %}{{ schema.title }}{% else %}{{ schema_name }}{% endif %} model
+    {% if schema.description %}
+    {{ schema.description }}
+    {% endif %}
+    {% if parent_comment %}
+    {{ parent_comment }}
+    {% endif %}
+    """
+    model_config = {
+        "populate_by_name": True,
+        "validate_assignment": True
+    }
+    {% for property in properties %}
+
+    {{ property.name | normalize_symbol }} : {{ property.type.converted_type | safe }} = Field(validation_alias="{{ property.name }}"{% if property.default is not none %}, default = {{ property.default }}{% endif %})
+    {% endfor %}

pydantic_openapi_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -0,0 +1,150 @@
+{% if env_token_name is not none %}import os{% endif %}
+
+from __future__ import annotations
+
+from collections.abc import Generator
+from typing import Any, Dict, Optional, Union
+import json
+
+import httpx
+from pydantic import BaseModel, TypeAdapter
+
+from ..models import *
+from ..exceptions import HTTPException
+
+{% set _base_url = servers[0].url if servers|length > 0 else "/" %}
+
+
+class SyncClient(BaseModel):
+    model_config = {"validate_assignment": True}
+
+    base_url: str = "{{ _base_url }}"
+    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 %}) -> {%- if op.is_sse -%}
+Generator[str | dict[str, Any], None, None]
+{%- else -%}
+{%- if op.return_type.type is none or op.return_type.type.converted_type is none -%}None
+{%- elif op.return_type.list_type is not none -%}list[{{ op.return_type.list_type }}]
+{%- else -%}{{ op.return_type.type.converted_type }}
+{%- endif -%}
+{%- endif -%}:
+        base_url = self.base_url
+        path = f"{{ op.path_name }}"
+
+        headers = {
+{% if op.body_param %}
+            "Content-Type": "application/json",
+{% endif %}
+{% if op.is_sse %}
+            "Accept": "text/event-stream",
+{% else %}
+            "Accept": "application/json",
+{% endif %}
+        }
+
+        _token = self.get_access_token()
+        if _token:
+            headers["Authorization"] = f"Bearer {_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}
+
+{% if op.is_sse %}
+        with httpx.Client(base_url=base_url, verify=self.verify) as client:
+            with client.stream(
+                "{{ op.method }}",
+                httpx.URL(path),
+                headers=headers,
+                params=query_params,
+{% if op.body_param %}
+                json={{ op.body_param }},
+{% endif %}
+            ) as response:
+                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}",
+                    )
+
+                for line in response.iter_lines():
+                    if not line:
+                        continue
+                    if line.startswith("data:"):
+                        payload = line[len("data:"):].strip()
+                        if not payload:
+                            continue
+                        if payload == "[DONE]":
+                            break
+                        try:
+                            obj = json.loads(payload)
+                            if isinstance(obj, dict):
+                                yield obj
+                            else:
+                                yield payload
+                        except Exception:
+                            yield payload
+                    else:
+                        yield line
+{% else %}
+        with httpx.Client(base_url=base_url, 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()
+
+{% if op.return_type.type is none or op.return_type.type.converted_type is none %}
+        return None
+{% elif op.return_type.complex_type %}
+{% if op.return_type.list_type is none %}
+        return TypeAdapter({{ op.return_type.type.converted_type }}).validate_python(body)
+{% else %}
+        return TypeAdapter(list[{{ op.return_type.list_type }}]).validate_python(body)
+{% endif %}
+{% else %}
+        return body
+{% endif %}
+{% endif %}
+
+{% endfor %}

pydantic_openapi_generator/models.py

@@ -0,0 +1,86 @@
+from typing import List, Optional, Union
+
+from openapi_pydantic.v3.v3_0 import (
+    Operation as Operation30,
+)
+from openapi_pydantic.v3.v3_0 import (
+    PathItem as PathItem30,
+)
+from openapi_pydantic.v3.v3_0 import (
+    Schema as Schema30,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Operation as Operation31,
+)
+from openapi_pydantic.v3.v3_1 import (
+    PathItem as PathItem31,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Schema as Schema31,
+)
+from pydantic import BaseModel, Field
+
+# Type unions for compatibility with both OpenAPI 3.0 and 3.1
+Operation = Union[Operation30, Operation31]
+PathItem = Union[PathItem30, PathItem31]
+Schema = Union[Schema30, Schema31]
+
+
+class LibraryConfig(BaseModel):
+    name: str
+    library_name: str
+    template_name: str
+    include_async: bool
+    include_sync: bool
+
+
+class TypeConversion(BaseModel):
+    original_type: str
+    converted_type: str
+    import_types: Optional[List[str]] = None
+
+
+class OpReturnType(BaseModel):
+    type: Optional[TypeConversion] = None
+    status_code: int
+    complex_type: bool = False
+    list_type: Optional[str] = None
+
+
+class ServiceOperation(BaseModel):
+    params: str
+    operation_id: str
+    query_params: List[str]
+    header_params: List[str]
+    return_type: OpReturnType
+    operation: Operation
+    pathItem: PathItem
+    content: str
+    async_client: Optional[bool] = False
+    tag: Optional[str] = None
+    path_name: str
+    body_param: Optional[str] = None
+    method: str
+    is_sse: bool = False
+    use_orjson: bool = False
+
+
+class Property(BaseModel):
+    name: str
+    type: TypeConversion
+    required: bool
+    default: Optional[str]
+    import_type: Optional[List[str]] = None
+
+
+class Model(BaseModel):
+    file_name: str
+    content: str
+    openapi_object: Optional[Schema] = None
+    properties: List[Property] = []
+
+
+class ConversionResult(BaseModel):
+    models: List[Model] = Field(default_factory=list)
+    clients: List[Model] = Field(default_factory=list)
+    exceptions: List[Model] = Field(default_factory=list)

pydantic_openapi_generator/parsers/__init__.py

@@ -0,0 +1,13 @@
+"""
+OpenAPI parsers for different specification versions.
+"""
+
+from .openapi_30 import generate_code_3_0, parse_openapi_3_0
+from .openapi_31 import generate_code_3_1, parse_openapi_3_1
+
+__all__ = [
+    "parse_openapi_3_0",
+    "generate_code_3_0",
+    "parse_openapi_3_1",
+    "generate_code_3_1",
+]

pydantic_openapi_generator/parsers/openapi_30.py

@@ -0,0 +1,65 @@
+"""
+OpenAPI 3.0 specific parsing and generation.
+"""
+
+from typing import Optional
+
+from openapi_pydantic.v3.v3_0 import OpenAPI
+
+from pydantic_openapi_generator.common import HTTPLibrary, PydanticVersion
+from pydantic_openapi_generator.language_converters.python.generator import (
+    generator as base_generator,
+)
+from pydantic_openapi_generator.models import ConversionResult
+
+
+def parse_openapi_3_0(spec_data: dict) -> OpenAPI:
+    """
+    Parse OpenAPI 3.0 specification data.
+
+    Args:
+        spec_data: Dictionary containing OpenAPI 3.0 specification
+
+    Returns:
+        OpenAPI: Parsed OpenAPI 3.0 specification object
+
+    Raises:
+        ValidationError: If the specification is invalid
+    """
+    return OpenAPI(**spec_data)  # type: ignore - pydantic issue with extra fields
+
+
+def generate_code_3_0(
+    data: OpenAPI,
+    library: HTTPLibrary = HTTPLibrary.httpx,
+    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 OpenAPI 3.0 specification.
+
+    Args:
+        data: OpenAPI 3.0 specification object
+        library: HTTP library to use
+        env_token_name: Environment variable name for token
+        use_orjson: Whether to use orjson for serialization
+        custom_template_path: Custom template path
+        pydantic_version: Pydantic version to use
+
+    Returns:
+        ConversionResult: Generated code and metadata
+    """
+    from pydantic_openapi_generator.common import library_config_dict
+
+    library_config = library_config_dict[library]
+
+    return base_generator(
+        data=data,
+        library_config=library_config,
+        env_token_name=env_token_name,
+        use_orjson=use_orjson,
+        custom_template_path=custom_template_path,
+        pydantic_version=pydantic_version,
+    )

pydantic_openapi_generator/parsers/openapi_31.py

@@ -0,0 +1,65 @@
+"""
+OpenAPI 3.1 specific parsing and generation.
+"""
+
+from typing import Optional
+
+from openapi_pydantic.v3.v3_1 import OpenAPI
+
+from pydantic_openapi_generator.common import HTTPLibrary, PydanticVersion
+from pydantic_openapi_generator.language_converters.python.generator import (
+    generator as base_generator,
+)
+from pydantic_openapi_generator.models import ConversionResult
+
+
+def parse_openapi_3_1(spec_data: dict) -> OpenAPI:
+    """
+    Parse OpenAPI 3.1 specification data.
+
+    Args:
+        spec_data: Dictionary containing OpenAPI 3.1 specification
+
+    Returns:
+        OpenAPI: Parsed OpenAPI 3.1 specification object
+
+    Raises:
+        ValidationError: If the specification is invalid
+    """
+    return OpenAPI(**spec_data)  # type: ignore - pydantic issue with extra fields
+
+
+def generate_code_3_1(
+    data: OpenAPI,
+    library: HTTPLibrary = HTTPLibrary.httpx,
+    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 OpenAPI 3.1 specification.
+
+    Args:
+        data: OpenAPI 3.1 specification object
+        library: HTTP library to use
+        env_token_name: Environment variable name for token
+        use_orjson: Whether to use orjson for serialization
+        custom_template_path: Custom template path
+        pydantic_version: Pydantic version to use
+
+    Returns:
+        ConversionResult: Generated code and metadata
+    """
+    from pydantic_openapi_generator.common import library_config_dict
+
+    library_config = library_config_dict[library]
+
+    return base_generator(
+        data=data,
+        library_config=library_config,
+        env_token_name=env_token_name,
+        use_orjson=use_orjson,
+        custom_template_path=custom_template_path,
+        pydantic_version=pydantic_version,
+    )