openapi-python-generator 1.1.2.dev1734089718__py3-none-any.whl → 1.2.1.dev1757310194__py3-none-any.whl

openapi_python_generator/language_converters/python/service_generator.py

@@ -1,4 +1,5 @@
 import re
+from typing import Any
 from typing import Dict
 from typing import List
 from typing import Literal
@@ -7,7 +8,28 @@ from typing import Tuple
 from typing import Union
 
 import click
-from openapi_pydantic.v3.v3_0 import Reference, Schema, Operation, Parameter, RequestBody, Response, MediaType, PathItem
+from openapi_pydantic.v3 import (
+    Reference,
+    Schema,
+    Operation,
+    Parameter,
+    Response,
+    PathItem,
+)
+
+# Import version-specific types for isinstance checks
+from openapi_pydantic.v3.v3_0 import (
+    Reference as Reference30,
+    Schema as Schema30,
+    Response as Response30,
+    MediaType as MediaType30,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Reference as Reference31,
+    Schema as Schema31,
+    Response as Response31,
+    MediaType as MediaType31,
+)
 
 from openapi_python_generator.language_converters.python import common
 from openapi_python_generator.language_converters.python.common import normalize_symbol
@@ -24,6 +46,39 @@ from openapi_python_generator.models import ServiceOperation
 from openapi_python_generator.models import 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):
+    """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)
+    elif isinstance(reference_obj, Reference31):
+        return MediaType31(schema=reference_obj)
+    else:
+        # Fallback to v3.0 for generic Reference
+        return MediaType30(schema=reference_obj)
+
+
+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))
+
+
 HTTP_OPERATIONS = ["get", "post", "put", "delete", "options", "head", "patch", "trace"]
 
 
@@ -45,9 +100,14 @@ def generate_body_param(operation: Operation) -> Union[str, None]:
         if media_type is None:
             return None  # pragma: no cover
 
-        if isinstance(media_type.media_type_schema, Reference):
+        if isinstance(
+            media_type.media_type_schema, (Reference, Reference30, Reference31)
+        ):
+            return "data.dict()"
+        elif hasattr(media_type.media_type_schema, "ref"):
+            # Handle Reference objects from different OpenAPI versions
             return "data.dict()"
-        elif isinstance(media_type.media_type_schema, Schema):
+        elif isinstance(media_type.media_type_schema, (Schema, Schema30, Schema31)):
             schema = media_type.media_type_schema
             if schema.type == "array":
                 return "[i.dict() for i in data]"
@@ -64,11 +124,14 @@ def generate_body_param(operation: Operation) -> Union[str, None]:
 
 
 def generate_params(operation: Operation) -> str:
-    def _generate_params_from_content(content: Union[Reference, Schema]):
-        if isinstance(content, Reference):
-            return f"data : {content.ref.split('/')[-1]}"
-        else:
-            return f"data : {type_converter(content, True).converted_type}"
+    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 ""
@@ -109,40 +172,30 @@ def generate_params(operation: Operation) -> str:
         "application/json",
         "text/plain",
         "multipart/form-data",
+        "application/octet-stream",
     ]
 
-    if operation.requestBody is not None:
-        if (
-            isinstance(operation.requestBody, RequestBody)
-            and isinstance(operation.requestBody.content, dict)
-            and any(
-                [
-                    operation.requestBody.content.get(i) is not None
-                    for i in operation_request_body_types
-                ]
-            )
+    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 operation.requestBody.content.get(i) is not None
-            ][0]
-            content = operation.requestBody.content.get(get_keyword)
-            if content is not None and (
-                isinstance(content.media_type_schema, Schema)
-                or isinstance(content.media_type_schema, Reference)
-            ):
-                params += (
-                    f"{_generate_params_from_content(content.media_type_schema)}, "
-                )
-            else:
-                raise Exception(
-                    f"Unsupported media type schema for {str(operation)}"
-                )  # pragma: no cover
-        else:
-            raise Exception(
-                f"Unsupported request body type: {type(operation.requestBody)}"
-            )
+            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("-", "_")
@@ -199,53 +252,59 @@ def generate_return_type(operation: Operation) -> OpReturnType:
         return OpReturnType(type=None, status_code=200, complex_type=False)
 
     chosen_response = good_responses[0][1]
+    media_type_schema = None
 
-    if isinstance(chosen_response, Response) and chosen_response.content is not None:
-        media_type_schema = chosen_response.content.get("application/json")
-    elif isinstance(chosen_response, Reference):
-        media_type_schema = MediaType(
-            media_type_schema=chosen_response
-        )  # pragma: no cover
-    else:
+    if is_response_type(chosen_response):
+        # It's a Response type, access content safely
+        if hasattr(chosen_response, "content") and getattr(chosen_response, "content") is not None:  # type: ignore
+            media_type_schema = getattr(chosen_response, "content").get("application/json")  # type: ignore
+    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 isinstance(media_type_schema, MediaType):
-        if isinstance(media_type_schema.media_type_schema, Reference):
+    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=media_type_schema.media_type_schema.ref,
-                converted_type=media_type_schema.media_type_schema.ref.split("/")[-1],
-                import_types=[media_type_schema.media_type_schema.ref.split("/")[-1]],
+                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 isinstance(media_type_schema.media_type_schema, Schema):
-            converted_result = type_converter(media_type_schema.media_type_schema, True)
-            if "array" in converted_result.original_type and isinstance(
-                converted_result.import_types, list
+        elif is_schema_type(inner_schema):
+            converted_result = type_converter(inner_schema, True)  # type: ignore
+            if (
+                "array" in converted_result.original_type
+                and isinstance(converted_result.import_types, list)
             ):
                 matched = re.findall(r"List\[(.+)\]", converted_result.converted_type)
                 if len(matched) > 0:
                     list_type = matched[0]
-                else:
+                else:  # pragma: no cover
                     raise Exception(
                         f"Unable to parse list type from {converted_result.converted_type}"
-                    )  # pragma: no cover
+                    )
             else:
                 list_type = None
             return OpReturnType(
                 type=converted_result,
                 status_code=good_responses[0][0],
-                complex_type=converted_result.import_types is not None
-                and len(converted_result.import_types) > 0,
+                complex_type=bool(
+                    converted_result.import_types
+                    and len(converted_result.import_types) > 0
+                ),
                 list_type=list_type,
             )
-        else:
-            raise Exception("Unknown media type schema type")  # pragma: no cover
+        else:  # pragma: no cover
+            raise Exception("Unknown media type schema type")
     elif media_type_schema is None:
         return OpReturnType(
             type=None,
@@ -269,7 +328,40 @@ def generate_services(
     def generate_service_operation(
         op: Operation, path_name: str, async_type: bool
     ) -> ServiceOperation:
+        # Merge path-level parameters (always required by spec) into the
+        # operation-level parameters so they get turned into function args.
+        try:
+            path_level_params = []
+            if hasattr(path, "parameters") and getattr(path, "parameters") is not None:  # type: ignore
+                path_level_params = [p for p in getattr(path, "parameters") if p is not None]  # type: ignore
+            if path_level_params:
+                existing_names = set()
+                if op.parameters is not None:
+                    for p in op.parameters:  # type: ignore
+                        if isinstance(p, Parameter):
+                            existing_names.add(p.name)
+                for p in path_level_params:
+                    if isinstance(p, Parameter) and p.name not in existing_names:
+                        if op.parameters is None:
+                            op.parameters = []  # type: ignore
+                        op.parameters.append(p)  # type: ignore
+        except Exception:  # pragma: no cover
+            pass
+
         params = generate_params(op)
+        # Fallback: ensure all {placeholders} in path are present as function params
+        try:
+            placeholder_names = [m.group(1) for m in re.finditer(r"\{([^}/]+)\}", path_name)]
+            existing_param_names = {
+                p.split(":")[0].strip()
+                for p in params.split(",") if ":" in p
+            }
+            for ph in placeholder_names:
+                norm_ph = common.normalize_symbol(ph)
+                if norm_ph not in existing_param_names and norm_ph:
+                    params = f"{norm_ph}: Any, " + params
+        except Exception:  # pragma: no cover
+            pass
         operation_id = generate_operation_id(op, http_operation, path_name)
         query_params = generate_query_params(op)
         header_params = generate_header_params(op)
@@ -293,7 +385,7 @@ def generate_services(
         )
 
         so.content = jinja_env.get_template(library_config.template_name).render(
-            **so.dict()
+            **so.model_dump()
         )
 
         if op.tags is not None and len(op.tags) > 0:
@@ -322,6 +414,11 @@ def generate_services(
                 async_so = generate_service_operation(op, path_name, True)
                 service_ops.append(async_so)
 
+    # Ensure every operation has a tag; fallback to "default" for untagged operations
+    for so in service_ops:
+        if not so.tag:
+            so.tag = "default"
+
     tags = set([so.tag for so in service_ops])
 
     for tag in tags:

openapi_python_generator/language_converters/python/templates/aiohttp.jinja2

@@ -1,4 +1,4 @@
-async def {{ operation_id }}({{ params }} api_config_override : Optional[APIConfig] = None) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
+async def {{ operation_id }}(api_config_override : Optional[APIConfig] = None{% if params.strip() %}, *, {{ params.rstrip(', ') }}{% endif %}) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
     api_config = api_config_override if api_config_override else APIConfig()
 
     base_path = api_config.base_path
@@ -30,19 +30,20 @@ async def {{ operation_id }}({{ params }} api_config_override : Optional[APIConf
             json = {{ body_param }}
         {% endif %}
     {% endif %}
-        ) as inital_response:
-            if inital_response.status != {{ return_type.status_code }}:
-                raise HTTPException(inital_response.status, f'{{ operationId }} failed with status code: {inital_response.status}')
-            response = await inital_response.json()
+        ) as initial_response:
+            if initial_response.status != {{ return_type.status_code }}:
+                raise HTTPException(initial_response.status, f'{{ operation_id }} failed with status code: {initial_response.status}')
+            # Only parse JSON when a body is expected (avoid errors on 204 No Content)
+            body = None if {{ return_type.status_code }} == 204 else await initial_response.json()
 
 {% if return_type.type is none or return_type.type.converted_type is none %}
-            return None
+        return None
 {% elif return_type.complex_type %}
     {%- if return_type.list_type is none %}
-            return {{ return_type.type.converted_type }}(**response) if response is not None else {{ return_type.type.converted_type }}()
+        return {{ return_type.type.converted_type }}(**body) if body is not None else {{ return_type.type.converted_type }}()
     {%- else %}
-            return [{{ return_type.list_type }}(**item) for item in response]
+        return [{{ return_type.list_type }}(**item) for item in body]
     {%- endif %}
 {% else %}
-            return response
+        return body
 {% endif %}

openapi_python_generator/language_converters/python/templates/httpx.jinja2

@@ -1,4 +1,4 @@
-{%  if async_client %}async {% endif %}def {{ operation_id }}({{ params }} api_config_override : Optional[APIConfig] = None) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
+{%  if async_client %}async {% endif %}def {{ operation_id }}(api_config_override : Optional[APIConfig] = None{% if params.strip() %}, *, {{ params.rstrip(', ') }}{% endif %}) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
     api_config = api_config_override if api_config_override else APIConfig()
 
     base_path = api_config.base_path
@@ -38,16 +38,19 @@ with httpx.Client(base_url=base_path, verify=api_config.verify) as client:
     )
 
     if response.status_code != {{ return_type.status_code }}:
-        raise HTTPException(response.status_code, f'{{ operationId }} failed with status code: {response.status_code}')
+        raise HTTPException(response.status_code, f'{{ operation_id }} failed with status code: {response.status_code}')
+    else:
+        {# Conditional body parsing: avoid calling .json() for 204 #}
+        body = None if {{ return_type.status_code }} == 204 else response.json()
 
 {% if return_type.type is none or return_type.type.converted_type is none %}
     return None
 {% elif return_type.complex_type %}
     {%- if return_type.list_type is none %}
-    return {{ return_type.type.converted_type }}(**response.json()) if response.json() is not None else {{ return_type.type.converted_type }}()
+    return {{ return_type.type.converted_type }}(**body) if body is not None else {{ return_type.type.converted_type }}()
     {%- else %}
-    return [{{ return_type.list_type }}(**item) for item in response.json()]
+    return [{{ return_type.list_type }}(**item) for item in body]
     {%- endif %}
 {% else %}
-    return response.json()
+    return body
 {% endif %}

openapi_python_generator/language_converters/python/templates/models.jinja2

@@ -10,11 +10,13 @@ from pydantic import BaseModel, Field
 
 class {{ schema_name }}(BaseModel):
     """
-    {{ schema.title }} model
-    {% if schema.description != None %}
+    {% 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 %}
 

openapi_python_generator/language_converters/python/templates/models_pydantic_2.jinja2

@@ -10,11 +10,13 @@ from pydantic import BaseModel, Field
 
 class {{ schema_name }}(BaseModel):
     """
-    {{ schema.title }} model
-    {% if schema.description != None %}
+    {% 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,

openapi_python_generator/language_converters/python/templates/requests.jinja2

@@ -1,4 +1,4 @@
-def {{ operation_id }}({{ params }} api_config_override : Optional[APIConfig] = None) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
+def {{ operation_id }}(api_config_override : Optional[APIConfig] = None{% if params.strip() %}, *, {{ params.rstrip(', ') }}{% endif %}) -> {% if return_type.type is none or return_type.type.converted_type is none %}None{% else %}{{ return_type.type.converted_type}}{% endif %}:
     api_config = api_config_override if api_config_override else APIConfig()
 
     base_path = api_config.base_path
@@ -32,16 +32,19 @@ def {{ operation_id }}({{ params }} api_config_override : Optional[APIConfig] =
         {% endif %}
     )
     if response.status_code != {{ return_type.status_code }}:
-        raise HTTPException(response.status_code, f'{{ operationId }} failed with status code: {response.status_code}')
+        raise HTTPException(response.status_code, f'{{ operation_id }} failed with status code: {response.status_code}')
+    else:
+        {# Conditional body parsing: avoid calling .json() for 204 #}
+        body = None if {{ return_type.status_code }} == 204 else response.json()
 
 {% if return_type.type is none or return_type.type.converted_type is none %}
     return None
 {% elif return_type.complex_type %}
     {%- if return_type.list_type is none %}
-    return {{ return_type.type.converted_type }}(**response.json()) if response.json() is not None else {{ return_type.type.converted_type }}()
+    return {{ return_type.type.converted_type }}(**body) if body is not None else {{ return_type.type.converted_type }}()
     {%- else %}
-    return [{{ return_type.list_type }}(**item) for item in response.json()]
+    return [{{ return_type.list_type }}(**item) for item in body]
     {%- endif %}
 {% else %}
-    return response.json()
+    return body
 {% endif %}

openapi_python_generator/language_converters/python/templates/service.jinja2

@@ -1,8 +1,9 @@
 from typing import *
 import {{ library_import }}
-import json
+
 {% if use_orjson %}
 import orjson
+from uuid import UUID
 {% endif %}
 
 from ..models import *

openapi_python_generator/models.py

@@ -1,9 +1,23 @@
-from typing import List
+from typing import List, Union
 from typing import Optional
 
-from openapi_pydantic.v3.v3_0 import Operation, PathItem, Schema
+from openapi_pydantic.v3.v3_0 import (
+    Operation as Operation30,
+    PathItem as PathItem30,
+    Schema as Schema30,
+)
+from openapi_pydantic.v3.v3_1 import (
+    Operation as Operation31,
+    PathItem as PathItem31,
+    Schema as Schema31,
+)
 from pydantic import BaseModel
 
+# 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

openapi_python_generator/parsers/__init__.py

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

openapi_python_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 openapi_python_generator.common import HTTPLibrary, PydanticVersion
+from openapi_python_generator.language_converters.python.generator import (
+    generator as base_generator,
+)
+from openapi_python_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)
+
+
+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 openapi_python_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,
+    )

openapi_python_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 openapi_python_generator.common import HTTPLibrary, PydanticVersion
+from openapi_python_generator.language_converters.python.generator import (
+    generator as base_generator,
+)
+from openapi_python_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)
+
+
+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 openapi_python_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,
+    )