pydantic-openapi-generator 2.2.8__tar.gz → 2.3.0__tar.gz

{pydantic_openapi_generator-2.2.8 → pydantic_openapi_generator-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: pydantic-openapi-generator
-Version: 2.2.8
+Version: 2.3.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.2.8 → pydantic_openapi_generator-2.3.0}/pyproject.toml

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

{pydantic_openapi_generator-2.2.8 → pydantic_openapi_generator-2.3.0}/src/pydantic_openapi_generator/language_converters/python/client_generator.py

@@ -52,6 +52,8 @@ from pydantic_openapi_generator.models import (
     LibraryConfig,
     Model,
     OpReturnType,
+    RequestBodyDefinition,
+    ResponseVariant,
     ServiceOperation,
     TypeConversion,
 )
@@ -141,52 +143,98 @@ def operation_is_sse(op: Operation) -> bool:
 HTTP_OPERATIONS = ["get", "post", "put", "delete", "options", "head", "patch", "trace"]
 
 
-def generate_body_param(operation: Operation) -> Union[str, None]:
+def _json_body_expression(media_type_schema: Any) -> str:
+    if isinstance(media_type_schema, (Reference, Reference30, Reference31)) or hasattr(media_type_schema, "ref"):
+        return "data.model_dump(by_alias=True, exclude_none=True)"
+
+    if isinstance(media_type_schema, (Schema, Schema30, Schema31)):
+        schema = media_type_schema
+
+        if schema.type == "array":
+            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":
+            return "data.model_dump(by_alias=True, exclude_none=True) if hasattr(data, 'model_dump') else data"
+
+        return "data"
+
+    raise Exception(f"Unsupported schema type for request body: {type(media_type_schema)}")  # pragma: no cover
+
+
+def generate_request_body(operation: Operation) -> Union[RequestBodyDefinition, 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)"
+        return RequestBodyDefinition(
+            content_type="application/json",
+            encoding="json",
+            expression="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
+    ordered_content_types = [
+        "application/json",
+        "multipart/form-data",
+        "application/x-www-form-urlencoded",
+        "application/octet-stream",
+        "text/plain",
+    ]
+    content_type = next((ct for ct in ordered_content_types if rb_content.get(ct) is not None), None)
+    if content_type is None:
+        return None
 
-    media_type = rb_content.get("application/json")
+    media_type = rb_content.get(content_type)
     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
+    if content_type == "application/json":
+        if mts is None:
+            return None  # pragma: no cover
+        return RequestBodyDefinition(
+            content_type=content_type,
+            encoding="json",
+            expression=_json_body_expression(mts),
+        )
 
-    # $ref schema -> model
-    if isinstance(mts, (Reference, Reference30, Reference31)) or hasattr(mts, "ref"):
-        return "data.model_dump(by_alias=True, exclude_none=True)"
+    if content_type == "multipart/form-data":
+        return RequestBodyDefinition(content_type=None, encoding="multipart", expression="data")
 
-    # Concrete schema
-    if isinstance(mts, (Schema, Schema30, Schema31)):
-        schema = mts
+    if content_type == "application/x-www-form-urlencoded":
+        return RequestBodyDefinition(content_type=content_type, encoding="form", expression="data")
 
-        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 content_type == "application/octet-stream":
+        return RequestBodyDefinition(content_type=content_type, encoding="binary", expression="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"
+    if content_type == "text/plain":
+        return RequestBodyDefinition(content_type=content_type, encoding="text", expression="data")
+
+    return None  # pragma: no cover
 
-        # Primitive (string/int/etc.)
-        return "data"
 
-    raise Exception(f"Unsupported schema type for request body: {type(mts)}")  # pragma: no cover
+def generate_body_param(operation: Operation) -> Union[str, None]:
+    request_body = generate_request_body(operation)
+    return None if request_body is None else request_body.expression
 
 
 def generate_params(operation: Operation) -> str:
+    def _schema_default(schema: Any) -> Any:
+        default = getattr(schema, "default", None)
+        if default is None:
+            return None
+        return default
+
+    def _default_suffix(schema: Any, required: bool) -> str:
+        if required:
+            return ""
+        default = _schema_default(schema)
+        return f" = {default!r}" if default is not None else " = None"
+
     def _generate_params_from_content(content: Any):
         # Accept reference from either 3.0 or 3.1
         if isinstance(content, (Reference, Reference30, Reference31)):
@@ -212,7 +260,7 @@ def generate_params(operation: Operation) -> str:
             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")
+                    + _default_suffix(param.param_schema, param.required)
                 )
                 required = param.required
             elif isinstance(param.param_schema, Reference30) or isinstance(param.param_schema, Reference31):
@@ -232,6 +280,7 @@ def generate_params(operation: Operation) -> str:
         "application/json",
         "text/plain",
         "multipart/form-data",
+        "application/x-www-form-urlencoded",
         "application/octet-stream",
     ]
 
@@ -290,95 +339,175 @@ 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)
+def _is_binary_schema(schema: Any) -> bool:
+    schema_format = getattr(schema, "schema_format", None)
+    schema_type = getattr(schema, "type", None)
+    return (schema_type == "string" or str(schema_type) == "DataType.STRING") and schema_format == "binary"
+
+
+def _body_kind_for_content(
+    content_type: Optional[str], schema: Any = None
+) -> Literal["empty", "json", "text", "binary"]:
+    if content_type is None:
+        return "empty"
+    lowered = content_type.lower()
+    if lowered == "application/json" or lowered.endswith("+json"):
+        return "json"
+    if lowered == "application/pdf" or lowered == "application/octet-stream" or _is_binary_schema(schema):
+        return "binary"
+    if lowered.startswith("text/"):
+        return "text"
+    return "binary"
+
+
+def _response_variant_from_schema(
+    status_code: int,
+    content_type: Optional[str],
+    inner_schema: Any,
+) -> ResponseVariant:
+    body_kind = _body_kind_for_content(content_type, inner_schema)
+    if body_kind == "empty":
+        return ResponseVariant(status_code=status_code, content_type=content_type, body_kind="empty")
+
+    if body_kind == "binary":
+        return ResponseVariant(
+            status_code=status_code,
+            content_type=content_type,
+            type=TypeConversion(original_type=content_type or "binary", converted_type="bytes"),
+            body_kind="binary",
+        )
 
-    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 body_kind == "text":
+        return ResponseVariant(
+            status_code=status_code,
+            content_type=content_type,
+            type=TypeConversion(original_type=content_type or "text", converted_type="str"),
+            body_kind="text",
+        )
+
+    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 ResponseVariant(
+            status_code=status_code,
+            content_type=content_type,
+            type=type_conv,
+            complex_type=True,
+            body_kind="json",
+        )
+
+    if is_schema_type(inner_schema):
+        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 media_type_schema is None:
-        return OpReturnType(type=None, status_code=good_responses[0][0], complex_type=False)
+        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"
 
-    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
+                original_type="discriminated_union",
+                converted_type=alias_name,
+                import_types=None,
             )
-            return OpReturnType(
+            return ResponseVariant(
+                status_code=status_code,
+                content_type=content_type,
                 type=type_conv,
-                status_code=good_responses[0][0],
                 complex_type=True,
+                body_kind="json",
             )
-        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,
+        converted_result = type_converter(inner_schema, True)  # type: ignore
+        list_type = None
+        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}")
+
+        return ResponseVariant(
+            status_code=status_code,
+            content_type=content_type,
+            type=converted_result,
+            complex_type=bool(converted_result.import_types and len(converted_result.import_types) > 0),
+            list_type=list_type,
+            body_kind="json",
         )
-    else:
-        raise Exception("Unknown media type schema type")  # pragma: no cover
+
+    return ResponseVariant(status_code=status_code, content_type=content_type, body_kind="empty")
+
+
+def _response_variants_for_response(status_code: int, response: Union[Response, Reference]) -> List[ResponseVariant]:
+    if is_reference_type(response):
+        media_type = create_media_type_for_reference(response)
+        inner_schema = getattr(media_type, "media_type_schema", None)
+        return [_response_variant_from_schema(status_code, "application/json", inner_schema)]
+
+    if not is_response_type(response):
+        return []
+
+    content = getattr(response, "content", None)
+    if not isinstance(content, dict) or not content:
+        return [ResponseVariant(status_code=status_code, content_type=None, body_kind="empty")]
+
+    variants: List[ResponseVariant] = []
+    for content_type, media_type in content.items():
+        if not is_media_type(media_type):
+            continue
+        inner_schema = getattr(media_type, "media_type_schema", None)
+        variants.append(_response_variant_from_schema(status_code, content_type, inner_schema))
+
+    return variants or [ResponseVariant(status_code=status_code, content_type=None, body_kind="empty")]
+
+
+def _return_type_hint(variants: List[ResponseVariant]) -> str:
+    hints: List[str] = []
+    for variant in variants:
+        if variant.body_kind == "empty" or variant.type is None:
+            hint = "None"
+        elif variant.list_type is not None:
+            hint = f"list[{variant.list_type}]"
+        else:
+            hint = variant.type.converted_type
+        if hint not in hints:
+            hints.append(hint)
+    if not hints:
+        return "None"
+    return hints[0] if len(hints) == 1 else " | ".join(hints)
+
+
+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])
+
+    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, accepted_status_codes=[200])
+
+    variants: List[ResponseVariant] = []
+    for status_code, response in good_responses:
+        variants.extend(_response_variants_for_response(status_code, response))
+
+    first_variant = variants[0] if variants else ResponseVariant(status_code=good_responses[0][0])
+    return OpReturnType(
+        type=first_variant.type,
+        status_code=first_variant.status_code,
+        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)),
+        return_type_hint=_return_type_hint(variants),
+    )
 
 
 def clean_up_path_name(path_name: str) -> str:
@@ -406,7 +535,11 @@ def generate_clients(
     service_ops: List[ServiceOperation] = []
 
     def _generate_service_operation(
-        op: Operation, path_obj: PathItem, path_name: str, http_operation: str, async_type: bool
+        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:
@@ -435,7 +568,8 @@ def generate_clients(
         query_params = generate_query_params(op)
         header_params = generate_header_params(op)
         return_type = generate_return_type(op)
-        body_param = generate_body_param(op)
+        request_body = generate_request_body(op)
+        body_param = None if request_body is None else request_body.expression
 
         so = ServiceOperation(
             params=params,
@@ -448,6 +582,7 @@ def generate_clients(
             content="",
             async_client=async_type,
             body_param=body_param,
+            request_body=request_body,
             path_name=path_name,
             method=http_operation,
             is_sse=operation_is_sse(op),
@@ -488,8 +623,18 @@ def generate_clients(
     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=[]),
+        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-2.2.8 → pydantic_openapi_generator-2.3.0}/src/pydantic_openapi_generator/language_converters/python/templates/async_client_httpx_pydantic_2.jinja2

@@ -48,24 +48,27 @@ class AsyncClient(BaseModel):
     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 -%}
+{{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
         base_url = self.base_url
         path = f"{{ op.path_name }}"
 
         headers = {
-{% if op.body_param %}
+{% if op.request_body and op.request_body.content_type %}
+            "Content-Type": "{{ op.request_body.content_type }}",
+{% elif op.body_param and not op.request_body %}
             "Content-Type": "application/json",
 {% endif %}
 {% if op.is_sse %}
             "Accept": "text/event-stream",
 {% else %}
-            "Accept": "application/json",
+            "Accept": "{{ op.return_type.accept_content_types | join(', ') or 'application/json' }}",
 {% endif %}
+{% for hp in op.header_params %}
+            {{ hp }},
+{% endfor %}
         }
+        headers = {k: v for (k, v) in headers.items() if v is not None}
 
         _token = await self.get_access_token()
         if _token:
@@ -86,10 +89,20 @@ AsyncGenerator[str | dict[str, Any], None]
                 headers=headers,
                 params=query_params,
 {% if op.body_param %}
+{% if op.request_body and op.request_body.encoding == "json" %}
+                json={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "multipart" %}
+                files={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "form" %}
+                data={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding in ["binary", "text"] %}
+                content={{ op.request_body.expression }},
+{% else %}
                 json={{ op.body_param }},
+{% endif %}
 {% endif %}
             ) as response:
-                if response.status_code != {{ op.return_type.status_code }}:
+                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}",
@@ -123,29 +136,51 @@ AsyncGenerator[str | dict[str, Any], None]
                 headers=headers,
                 params=query_params,
 {% if op.body_param %}
+{% if op.request_body and op.request_body.encoding == "json" %}
+                json={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "multipart" %}
+                files={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "form" %}
+                data={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding in ["binary", "text"] %}
+                content={{ op.request_body.expression }},
+{% else %}
                 json={{ op.body_param }},
+{% endif %}
 {% endif %}
             )
 
-        if response.status_code != {{ op.return_type.status_code }}:
+        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}",
             )
 
-        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)
+        _response_content_type = response.headers.get("content-type", "").split(";", 1)[0].lower()
+{% 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" %}
+            return response.content
+{% elif variant.body_kind == "text" %}
+            return response.text
+{% elif variant.complex_type %}
+{% if variant.list_type is none %}
+            return TypeAdapter({{ variant.type.converted_type }}).validate_python(response.json())
 {% else %}
-        return TypeAdapter(list[{{ op.return_type.list_type }}]).validate_python(body)
+            return TypeAdapter(list[{{ variant.list_type }}]).validate_python(response.json())
 {% endif %}
 {% else %}
-        return body
+            return response.json()
 {% endif %}
+
+{% endfor %}
+        raise HTTPException(
+            response.status_code,
+            f"{{ op.operation_id }} failed with unsupported content type: {_response_content_type}",
+        )
 {% endif %}
 
 {% endfor %}

{pydantic_openapi_generator-2.2.8 → pydantic_openapi_generator-2.3.0}/src/pydantic_openapi_generator/language_converters/python/templates/sync_client_httpx_pydantic_2.jinja2

@@ -48,24 +48,27 @@ class SyncClient(BaseModel):
     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 -%}
+{{ op.return_type.return_type_hint or "None" }}
 {%- endif -%}:
         base_url = self.base_url
         path = f"{{ op.path_name }}"
 
         headers = {
-{% if op.body_param %}
+{% if op.request_body and op.request_body.content_type %}
+            "Content-Type": "{{ op.request_body.content_type }}",
+{% elif op.body_param and not op.request_body %}
             "Content-Type": "application/json",
 {% endif %}
 {% if op.is_sse %}
             "Accept": "text/event-stream",
 {% else %}
-            "Accept": "application/json",
+            "Accept": "{{ op.return_type.accept_content_types | join(', ') or 'application/json' }}",
 {% endif %}
+{% for hp in op.header_params %}
+            {{ hp }},
+{% endfor %}
         }
+        headers = {k: v for (k, v) in headers.items() if v is not None}
 
         _token = self.get_access_token()
         if _token:
@@ -86,10 +89,20 @@ Generator[str | dict[str, Any], None, None]
                 headers=headers,
                 params=query_params,
 {% if op.body_param %}
+{% if op.request_body and op.request_body.encoding == "json" %}
+                json={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "multipart" %}
+                files={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "form" %}
+                data={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding in ["binary", "text"] %}
+                content={{ op.request_body.expression }},
+{% else %}
                 json={{ op.body_param }},
+{% endif %}
 {% endif %}
             ) as response:
-                if response.status_code != {{ op.return_type.status_code }}:
+                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}",
@@ -122,29 +135,51 @@ Generator[str | dict[str, Any], None, None]
                 headers=headers,
                 params=query_params,
 {% if op.body_param %}
+{% if op.request_body and op.request_body.encoding == "json" %}
+                json={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "multipart" %}
+                files={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding == "form" %}
+                data={{ op.request_body.expression }},
+{% elif op.request_body and op.request_body.encoding in ["binary", "text"] %}
+                content={{ op.request_body.expression }},
+{% else %}
                 json={{ op.body_param }},
+{% endif %}
 {% endif %}
             )
 
-        if response.status_code != {{ op.return_type.status_code }}:
+        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}",
             )
 
-        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)
+        _response_content_type = response.headers.get("content-type", "").split(";", 1)[0].lower()
+{% 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" %}
+            return response.content
+{% elif variant.body_kind == "text" %}
+            return response.text
+{% elif variant.complex_type %}
+{% if variant.list_type is none %}
+            return TypeAdapter({{ variant.type.converted_type }}).validate_python(response.json())
 {% else %}
-        return TypeAdapter(list[{{ op.return_type.list_type }}]).validate_python(body)
+            return TypeAdapter(list[{{ variant.list_type }}]).validate_python(response.json())
 {% endif %}
 {% else %}
-        return body
+            return response.json()
 {% endif %}
+
+{% endfor %}
+        raise HTTPException(
+            response.status_code,
+            f"{{ op.operation_id }} failed with unsupported content type: {_response_content_type}",
+        )
 {% endif %}
 
 {% endfor %}

{pydantic_openapi_generator-2.2.8 → pydantic_openapi_generator-2.3.0}/src/pydantic_openapi_generator/models.py

@@ -1,4 +1,4 @@
-from typing import List, Optional, Union
+from typing import List, Literal, Optional, Union
 
 from openapi_pydantic.v3.v3_0 import (
     Operation as Operation30,
@@ -45,6 +45,25 @@ class OpReturnType(BaseModel):
     status_code: int
     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)
+    return_type_hint: Optional[str] = None
+
+
+class ResponseVariant(BaseModel):
+    status_code: int
+    content_type: Optional[str] = None
+    type: Optional[TypeConversion] = None
+    complex_type: bool = False
+    list_type: Optional[str] = None
+    body_kind: Literal["empty", "json", "text", "binary"] = "empty"
+
+
+class RequestBodyDefinition(BaseModel):
+    content_type: Optional[str] = None
+    encoding: Literal["json", "form", "multipart", "binary", "text"]
+    expression: str
 
 
 class ServiceOperation(BaseModel):
@@ -60,6 +79,7 @@ class ServiceOperation(BaseModel):
     tag: Optional[str] = None
     path_name: str
     body_param: Optional[str] = None
+    request_body: Optional[RequestBodyDefinition] = None
     method: str
     is_sse: bool = False
     use_orjson: bool = False