pydantic-openapi-generator 2.4.0__tar.gz → 2.5.0__tar.gz

{pydantic_openapi_generator-2.4.0 → pydantic_openapi_generator-2.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pydantic-openapi-generator
-Version: 2.4.0
+Version: 2.5.0
 Summary: Openapi Python Generator
 Project-URL: Homepage, https://github.com/mattcoulter7/pydantic-openapi-generator
 Project-URL: Repository, https://github.com/mattcoulter7/pydantic-openapi-generator

{pydantic_openapi_generator-2.4.0 → pydantic_openapi_generator-2.5.0}/pyproject.toml

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

{pydantic_openapi_generator-2.4.0 → pydantic_openapi_generator-2.5.0}/src/pydantic_openapi_generator/language_converters/python/client_generator.py

@@ -58,6 +58,7 @@ from pydantic_openapi_generator.models import (
     Model,
     OpReturnType,
     RequestBodyDefinition,
+    ResponseContentHandler,
     ResponseVariant,
     ServiceOperation,
     TypeConversion,
@@ -154,6 +155,71 @@ def operation_is_sse(op: Operation) -> bool:
     return False
 
 
+def _sse_data_schema_from_media_type(media_type: Any) -> Any:
+    media_type_schema = getattr(media_type, "media_type_schema", None)
+    if media_type_schema is None:
+        return None
+
+    if is_reference_type(media_type_schema):
+        return media_type_schema
+
+    if not is_schema_type(media_type_schema):
+        return None
+
+    properties = getattr(media_type_schema, "properties", None)
+    if isinstance(properties, dict) and "data" in properties:
+        return properties["data"]
+
+    schema_type = getattr(media_type_schema, "type", None)
+    if schema_type != "object" and str(schema_type) != "DataType.OBJECT":
+        return media_type_schema
+
+    return None
+
+
+def generate_sse_data_handler(operation: Operation) -> Optional[ResponseContentHandler]:
+    if not getattr(operation, "responses", None):
+        return None
+
+    for status_code, response in operation.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
+
+        if not is_response_type(response):
+            continue
+
+        content = getattr(response, "content", None)
+        if not isinstance(content, dict):
+            continue
+
+        media_type = content.get("text/event-stream")
+        if not is_media_type(media_type):
+            continue
+
+        data_schema = _sse_data_schema_from_media_type(media_type)
+        if data_schema is None:
+            continue
+
+        variant = _response_variant_from_schema(int(status_code), "application/json", data_schema)
+        if variant.type is None or variant.body_kind == "empty":
+            continue
+
+        return ResponseContentHandler(
+            content_type="text/event-stream",
+            type=variant.type,
+            complex_type=variant.complex_type,
+            list_type=variant.list_type,
+            body_kind=variant.body_kind,  # type: ignore[arg-type]
+        )
+
+    return None
+
+
 HTTP_OPERATIONS = ["get", "post", "put", "delete", "options", "head", "patch", "trace"]
 
 
@@ -620,9 +686,47 @@ def _return_type_hint(variants: List[ResponseVariant]) -> str:
     return hints[0] if len(hints) == 1 else " | ".join(hints)
 
 
+def _variant_deserialization_key(variant: ResponseVariant) -> tuple:
+    return (
+        variant.body_kind,
+        variant.type.converted_type if variant.type is not None else None,
+        variant.complex_type,
+        variant.list_type,
+    )
+
+
+def _unambiguous_content_handlers(
+    variants: List[ResponseVariant],
+) -> List[ResponseContentHandler]:
+    variants_by_content_type: Dict[str, List[ResponseVariant]] = {}
+    for variant in variants:
+        if variant.content_type is None or variant.body_kind == "empty":
+            continue
+        variants_by_content_type.setdefault(variant.content_type.lower(), []).append(variant)
+
+    handlers: List[ResponseContentHandler] = []
+    for content_type, content_variants in variants_by_content_type.items():
+        keys = {_variant_deserialization_key(variant) for variant in content_variants}
+        if len(keys) != 1:
+            continue
+
+        variant = content_variants[0]
+        handlers.append(
+            ResponseContentHandler(
+                content_type=content_type,
+                type=variant.type,
+                complex_type=variant.complex_type,
+                list_type=variant.list_type,
+                body_kind=variant.body_kind,  # type: ignore[arg-type]
+            )
+        )
+
+    return handlers
+
+
 def generate_return_type(operation: Operation) -> OpReturnType:
     if operation.responses is None:
-        return OpReturnType(type=None, status_code=200, complex_type=False, accepted_status_codes=[200])
+        return OpReturnType(type=None, status_code=200, complex_type=False)
 
     good_responses: List[Tuple[int, Union[Response, Reference]]] = [
         (int(status_code), response)
@@ -630,7 +734,7 @@ def generate_return_type(operation: Operation) -> OpReturnType:
         if status_code.startswith("2")
     ]
     if len(good_responses) == 0:
-        return OpReturnType(type=None, status_code=200, complex_type=False, accepted_status_codes=[200])
+        return OpReturnType(type=None, status_code=200, complex_type=False)
 
     variants: List[ResponseVariant] = []
     for status_code, response in good_responses:
@@ -643,8 +747,8 @@ def generate_return_type(operation: Operation) -> OpReturnType:
         complex_type=first_variant.complex_type,
         list_type=first_variant.list_type,
         variants=variants,
-        accepted_status_codes=sorted({status_code for status_code, _ in good_responses}),
         accept_content_types=list(dict.fromkeys(v.content_type for v in variants if v.content_type is not None)),
+        unambiguous_content_handlers=_unambiguous_content_handlers(variants),
         return_type_hint=_return_type_hint(variants),
     )
 
@@ -732,6 +836,7 @@ def generate_clients(
             path_name=path_name,
             method=http_operation,
             is_sse=operation_is_sse(op),
+            sse_data_handler=generate_sse_data_handler(op),
             use_orjson=common.get_use_orjson(),
         )
 

{pydantic_openapi_generator-2.4.0 → pydantic_openapi_generator-2.5.0}/src/pydantic_openapi_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -10,7 +10,6 @@ import httpx
 from pydantic import BaseModel, SecretStr, TypeAdapter
 
 from ..models import *
-from ..exceptions import HTTPException
 
 {% set _base_url = servers[0].url if servers|length > 0 else "/" %}
 
@@ -54,7 +53,7 @@ class AsyncClient(BaseModel):
 {% endfor %}
 {% 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]
+AsyncGenerator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{% if op.sse_data_handler.list_type %}list[{{ op.sse_data_handler.list_type }}]{% else %}{{ op.sse_data_handler.type.converted_type }}{% endif %}{% else %}dict[str, Any]{% endif %}, None]
 {%- else -%}
 {{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
@@ -121,11 +120,7 @@ AsyncGenerator[str | dict[str, Any], None]
 {% endif %}
 {% endif %}
             ) as response:
-                if response.status_code not in {{ op.return_type.accepted_status_codes or [op.return_type.status_code] }}:
-                    raise HTTPException(
-                        response.status_code,
-                        f"{{ op.operation_id }} failed with status code: {response.status_code}",
-                    )
+                response.raise_for_status()
 
                 async for line in response.aiter_lines():
                     if not line:
@@ -137,11 +132,16 @@ AsyncGenerator[str | dict[str, Any], None]
                         if payload == "[DONE]":
                             break
                         try:
+{% if op.sse_data_handler and op.sse_data_handler.type %}
+                            obj = json.loads(payload)
+                            yield TypeAdapter({% if op.sse_data_handler.list_type %}list[{{ op.sse_data_handler.list_type }}]{% else %}{{ op.sse_data_handler.type.converted_type }}{% endif %}).validate_python(obj)
+{% else %}
                             obj = json.loads(payload)
                             if isinstance(obj, dict):
                                 yield obj
                             else:
                                 yield payload
+{% endif %}
                         except Exception:
                             yield payload
                     else:
@@ -169,23 +169,60 @@ AsyncGenerator[str | dict[str, Any], None]
 {% endif %}
             )
 
-        if response.status_code not in {{ op.return_type.accepted_status_codes or [op.return_type.status_code] }}:
-            raise HTTPException(
-                response.status_code,
-                f"{{ op.operation_id }} failed with status code: {response.status_code}",
-            )
+        response.raise_for_status()
+
+{% set empty_variants = op.return_type.variants | selectattr("body_kind", "equalto", "empty") | list %}
+{% if empty_variants|length > 0 %}
+        if not response.content:
+            return None
+
+{% endif %}
+{% if op.return_type.unambiguous_content_handlers|length == 1 %}
+{% set handler = op.return_type.unambiguous_content_handlers[0] %}
+{% if handler.body_kind == "binary" %}
+        return response.content
+{% elif handler.body_kind == "text" %}
+        return response.text
+{% elif handler.type is not none and handler.type.converted_type is not none %}
+{% if handler.list_type is none %}
+        return TypeAdapter({{ handler.type.converted_type }}).validate_python(response.json())
+{% else %}
+        return TypeAdapter(list[{{ handler.list_type }}]).validate_python(response.json())
+{% endif %}
+{% else %}
+        return response.json()
+{% endif %}
+{% else %}
+        if not response.content:
+            return None
 
         _response_content_type = response.headers.get("content-type", "").split(";", 1)[0].lower()
+{% set unambiguous_content_types = op.return_type.unambiguous_content_handlers | map(attribute="content_type") | list %}
+{% for handler in op.return_type.unambiguous_content_handlers %}
+        if _response_content_type == "{{ handler.content_type }}":
+{% if handler.body_kind == "binary" %}
+            return response.content
+{% elif handler.body_kind == "text" %}
+            return response.text
+{% elif handler.type is not none and handler.type.converted_type is not none %}
+{% if handler.list_type is none %}
+            return TypeAdapter({{ handler.type.converted_type }}).validate_python(response.json())
+{% else %}
+            return TypeAdapter(list[{{ handler.list_type }}]).validate_python(response.json())
+{% endif %}
+{% else %}
+            return response.json()
+{% endif %}
+
+{% endfor %}
 {% for variant in op.return_type.variants %}
-{% set same_status_variants = op.return_type.variants | selectattr("status_code", "equalto", variant.status_code) | list %}
-        if response.status_code == {{ variant.status_code }}{% if same_status_variants|length > 1 and variant.content_type %} and _response_content_type == "{{ variant.content_type }}"{% endif %}:
-{% if variant.body_kind == "empty" or variant.type is none or variant.type.converted_type is none %}
-            return None
-{% elif variant.body_kind == "binary" %}
+{% if variant.content_type and variant.body_kind != "empty" and variant.content_type not in unambiguous_content_types %}
+        if response.status_code == {{ variant.status_code }} and _response_content_type == "{{ variant.content_type }}":
+{% if variant.body_kind == "binary" %}
             return response.content
 {% elif variant.body_kind == "text" %}
             return response.text
-{% elif variant.complex_type %}
+{% elif variant.type is not none and variant.type.converted_type is not none %}
 {% if variant.list_type is none %}
             return TypeAdapter({{ variant.type.converted_type }}).validate_python(response.json())
 {% else %}
@@ -195,11 +232,16 @@ AsyncGenerator[str | dict[str, Any], None]
             return response.json()
 {% endif %}
 
+{% endif %}
 {% endfor %}
-        raise HTTPException(
-            response.status_code,
-            f"{{ op.operation_id }} failed with unsupported content type: {_response_content_type}",
-        )
+        if _response_content_type == "application/json" or _response_content_type.endswith("+json"):
+            return response.json()
+
+        if _response_content_type.startswith("text/"):
+            return response.text
+
+        return response.content
+{% endif %}
 {% endif %}
 
 {% endfor %}

{pydantic_openapi_generator-2.4.0 → pydantic_openapi_generator-2.5.0}/src/pydantic_openapi_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -10,7 +10,6 @@ import httpx
 from pydantic import BaseModel, SecretStr, TypeAdapter
 
 from ..models import *
-from ..exceptions import HTTPException
 
 {% set _base_url = servers[0].url if servers|length > 0 else "/" %}
 
@@ -54,7 +53,7 @@ class SyncClient(BaseModel):
 {% endfor %}
 {% 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]
+Generator[str | {% if op.sse_data_handler and op.sse_data_handler.type %}{% if op.sse_data_handler.list_type %}list[{{ op.sse_data_handler.list_type }}]{% else %}{{ op.sse_data_handler.type.converted_type }}{% endif %}{% else %}dict[str, Any]{% endif %}, None, None]
 {%- else -%}
 {{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
@@ -121,11 +120,7 @@ Generator[str | dict[str, Any], None, None]
 {% endif %}
 {% endif %}
             ) as response:
-                if response.status_code not in {{ op.return_type.accepted_status_codes or [op.return_type.status_code] }}:
-                    raise HTTPException(
-                        response.status_code,
-                        f"{{ op.operation_id }} failed with status code: {response.status_code}",
-                    )
+                response.raise_for_status()
 
                 for line in response.iter_lines():
                     if not line:
@@ -137,11 +132,16 @@ Generator[str | dict[str, Any], None, None]
                         if payload == "[DONE]":
                             break
                         try:
+{% if op.sse_data_handler and op.sse_data_handler.type %}
+                            obj = json.loads(payload)
+                            yield TypeAdapter({% if op.sse_data_handler.list_type %}list[{{ op.sse_data_handler.list_type }}]{% else %}{{ op.sse_data_handler.type.converted_type }}{% endif %}).validate_python(obj)
+{% else %}
                             obj = json.loads(payload)
                             if isinstance(obj, dict):
                                 yield obj
                             else:
                                 yield payload
+{% endif %}
                         except Exception:
                             yield payload
                     else:
@@ -168,23 +168,60 @@ Generator[str | dict[str, Any], None, None]
 {% endif %}
             )
 
-        if response.status_code not in {{ op.return_type.accepted_status_codes or [op.return_type.status_code] }}:
-            raise HTTPException(
-                response.status_code,
-                f"{{ op.operation_id }} failed with status code: {response.status_code}",
-            )
+        response.raise_for_status()
+
+{% set empty_variants = op.return_type.variants | selectattr("body_kind", "equalto", "empty") | list %}
+{% if empty_variants|length > 0 %}
+        if not response.content:
+            return None
+
+{% endif %}
+{% if op.return_type.unambiguous_content_handlers|length == 1 %}
+{% set handler = op.return_type.unambiguous_content_handlers[0] %}
+{% if handler.body_kind == "binary" %}
+        return response.content
+{% elif handler.body_kind == "text" %}
+        return response.text
+{% elif handler.type is not none and handler.type.converted_type is not none %}
+{% if handler.list_type is none %}
+        return TypeAdapter({{ handler.type.converted_type }}).validate_python(response.json())
+{% else %}
+        return TypeAdapter(list[{{ handler.list_type }}]).validate_python(response.json())
+{% endif %}
+{% else %}
+        return response.json()
+{% endif %}
+{% else %}
+        if not response.content:
+            return None
 
         _response_content_type = response.headers.get("content-type", "").split(";", 1)[0].lower()
+{% set unambiguous_content_types = op.return_type.unambiguous_content_handlers | map(attribute="content_type") | list %}
+{% for handler in op.return_type.unambiguous_content_handlers %}
+        if _response_content_type == "{{ handler.content_type }}":
+{% if handler.body_kind == "binary" %}
+            return response.content
+{% elif handler.body_kind == "text" %}
+            return response.text
+{% elif handler.type is not none and handler.type.converted_type is not none %}
+{% if handler.list_type is none %}
+            return TypeAdapter({{ handler.type.converted_type }}).validate_python(response.json())
+{% else %}
+            return TypeAdapter(list[{{ handler.list_type }}]).validate_python(response.json())
+{% endif %}
+{% else %}
+            return response.json()
+{% endif %}
+
+{% endfor %}
 {% for variant in op.return_type.variants %}
-{% set same_status_variants = op.return_type.variants | selectattr("status_code", "equalto", variant.status_code) | list %}
-        if response.status_code == {{ variant.status_code }}{% if same_status_variants|length > 1 and variant.content_type %} and _response_content_type == "{{ variant.content_type }}"{% endif %}:
-{% if variant.body_kind == "empty" or variant.type is none or variant.type.converted_type is none %}
-            return None
-{% elif variant.body_kind == "binary" %}
+{% if variant.content_type and variant.body_kind != "empty" and variant.content_type not in unambiguous_content_types %}
+        if response.status_code == {{ variant.status_code }} and _response_content_type == "{{ variant.content_type }}":
+{% if variant.body_kind == "binary" %}
             return response.content
 {% elif variant.body_kind == "text" %}
             return response.text
-{% elif variant.complex_type %}
+{% elif variant.type is not none and variant.type.converted_type is not none %}
 {% if variant.list_type is none %}
             return TypeAdapter({{ variant.type.converted_type }}).validate_python(response.json())
 {% else %}
@@ -194,11 +231,16 @@ Generator[str | dict[str, Any], None, None]
             return response.json()
 {% endif %}
 
+{% endif %}
 {% endfor %}
-        raise HTTPException(
-            response.status_code,
-            f"{{ op.operation_id }} failed with unsupported content type: {_response_content_type}",
-        )
+        if _response_content_type == "application/json" or _response_content_type.endswith("+json"):
+            return response.json()
+
+        if _response_content_type.startswith("text/"):
+            return response.text
+
+        return response.content
+{% endif %}
 {% endif %}
 
 {% endfor %}

{pydantic_openapi_generator-2.4.0 → pydantic_openapi_generator-2.5.0}/src/pydantic_openapi_generator/models.py

@@ -48,8 +48,8 @@ class OpReturnType(BaseModel):
     complex_type: bool = False
     list_type: Optional[str] = None
     variants: List["ResponseVariant"] = Field(default_factory=list)
-    accepted_status_codes: List[int] = Field(default_factory=list)
     accept_content_types: List[str] = Field(default_factory=list)
+    unambiguous_content_handlers: List["ResponseContentHandler"] = Field(default_factory=list)
     return_type_hint: Optional[str] = None
 
 
@@ -62,6 +62,14 @@ class ResponseVariant(BaseModel):
     body_kind: Literal["empty", "json", "text", "binary"] = "empty"
 
 
+class ResponseContentHandler(BaseModel):
+    content_type: str
+    type: Optional[TypeConversion] = None
+    complex_type: bool = False
+    list_type: Optional[str] = None
+    body_kind: Literal["json", "text", "binary"]
+
+
 class RequestBodyDefinition(BaseModel):
     content_type: Optional[str] = None
     encoding: Literal["json", "form", "multipart", "binary", "text"]
@@ -102,6 +110,7 @@ class ServiceOperation(BaseModel):
     request_body: Optional[RequestBodyDefinition] = None
     method: str
     is_sse: bool = False
+    sse_data_handler: Optional[ResponseContentHandler] = None
     use_orjson: bool = False