pyopenapi-gen 0.14.0__py3-none-any.whl → 0.14.2__py3-none-any.whl

pyopenapi_gen/visit/client_visitor.py

@@ -79,7 +79,7 @@ class ClientVisitor:
         # For now, the client_py_content check in the test looks for this for ApiKeyAuth specifically:
         context.add_import(f"{context.core_package_name}.auth.plugins", "ApiKeyAuth")
 
-        context.add_typing_imports_for_type("Optional[HttpTransport]")
+        context.add_typing_imports_for_type("HttpTransport | None")
         context.add_typing_imports_for_type("Any")
         context.add_typing_imports_for_type("Dict")
         # Class definition
@@ -103,7 +103,7 @@ class ClientVisitor:
         summary = "Async API client with pluggable transport, tag-specific clients, and client-level headers."
         args: list[tuple[str, str, str]] = [
             ("config", "ClientConfig", "Client configuration object."),
-            ("transport", "Optional[HttpTransport]", "Custom HTTP transport (optional)."),
+            ("transport", "HttpTransport | None", "Custom HTTP transport (optional)."),
         ]
         for tag, class_name, module_name in tag_tuples:
             args.append((module_name, class_name, f"Client for '{tag}' endpoints."))
@@ -121,9 +121,7 @@ class ClientVisitor:
         writer.indent()  # Back to class indent (1)
         writer.write_line('"""')
         # __init__
-        writer.write_line(
-            "def __init__(self, config: ClientConfig, transport: Optional[HttpTransport] = None) -> None:"
-        )
+        writer.write_line("def __init__(self, config: ClientConfig, transport: HttpTransport | None = None) -> None:")
         writer.indent()
         writer.write_line("self.config = config")
         writer.write_line(
@@ -133,8 +131,8 @@ class ClientVisitor:
         writer.write_line("self._base_url: str = str(self.config.base_url)")
         # Initialize private fields for each tag client
         for tag, class_name, module_name in tag_tuples:
-            context.add_typing_imports_for_type(f"Optional[{class_name}]")
-            writer.write_line(f"self._{module_name}: Optional[{class_name}] = None")
+            context.add_typing_imports_for_type(f"{class_name} | None")
+            writer.write_line(f"self._{module_name}: {class_name} | None = None")
         writer.dedent()
         writer.write_line("")
         # @property for each tag client

pyopenapi_gen/visit/endpoint/generators/docstring_generator.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import logging
 import textwrap  # For _wrap_docstring logic
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any
 
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
 from pyopenapi_gen.core.writers.documentation_writer import DocumentationBlock, DocumentationWriter
@@ -23,8 +23,8 @@ logger = logging.getLogger(__name__)
 class EndpointDocstringGenerator:
     """Generates the Python docstring for an endpoint operation."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
         self.doc_writer = DocumentationWriter(width=88)
 
     def _wrap_docstring(self, prefix: str, text: str, width: int = 88) -> str:
@@ -50,7 +50,7 @@ class EndpointDocstringGenerator:
         writer: CodeWriter,
         op: IROperation,
         context: RenderContext,
-        primary_content_type: Optional[str],
+        primary_content_type: str | None,
         response_strategy: ResponseStrategy,
     ) -> None:
         """Writes the method docstring to the provided CodeWriter."""
@@ -67,10 +67,10 @@ class EndpointDocstringGenerator:
             body_desc = op.request_body.description or "Request body."
             # Standardized body parameter names based on content type
             if primary_content_type == "multipart/form-data":
-                args.append(("files", "Dict[str, IO[Any]]", body_desc + " (multipart/form-data)"))
+                args.append(("files", "dict[str, IO[Any]]", body_desc + " (multipart/form-data)"))
             elif primary_content_type == "application/x-www-form-urlencoded":
-                # The type here could be more specific if schema is available, but Dict[str, Any] is a safe default.
-                args.append(("form_data", "Dict[str, Any]", body_desc + " (x-www-form-urlencoded)"))
+                # The type here could be more specific if schema is available, but dict[str, Any] is a safe default.
+                args.append(("form_data", "dict[str, Any]", body_desc + " (x-www-form-urlencoded)"))
             elif primary_content_type == "application/json":
                 body_type = get_request_body_type(op.request_body, context, self.schemas)
                 args.append(("body", body_type, body_desc + " (json)"))

pyopenapi_gen/visit/endpoint/generators/request_generator.py

@@ -5,7 +5,7 @@ Helper class for generating the HTTP request call for an endpoint method.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any
 
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
 
@@ -21,8 +21,8 @@ logger = logging.getLogger(__name__)
 class EndpointRequestGenerator:
     """Generates the self._transport.request(...) call for an endpoint method."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def generate_request_call(
         self,
@@ -30,8 +30,8 @@ class EndpointRequestGenerator:
         op: IROperation,
         context: RenderContext,  # Pass context for potential import needs
         has_header_params: bool,
-        primary_content_type: Optional[str],
-        # resolved_body_type: Optional[str], # May not be directly needed here if logic relies on var names
+        primary_content_type: str | None,
+        # resolved_body_type: str | None, # May not be directly needed here if logic relies on var names
     ) -> None:
         """Writes the self._transport.request call to the CodeWriter."""
         # Logic from EndpointMethodGenerator._write_request

pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py

@@ -5,7 +5,7 @@ Helper class for generating response handling logic for an endpoint method.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Optional, TypedDict
+from typing import TYPE_CHECKING, Any, TypedDict
 
 from pyopenapi_gen.core.http_status_codes import get_exception_class_name
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
@@ -44,8 +44,8 @@ class DefaultCase(TypedDict):
 class EndpointResponseHandlerGenerator:
     """Generates the response handling logic for an endpoint method."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def _is_type_alias_to_array(self, type_name: str) -> bool:
         """
@@ -130,7 +130,7 @@ class EndpointResponseHandlerGenerator:
         Determine if a type should use BaseSchema deserialization.
 
         Args:
-            type_name: The Python type name (e.g., "User", "List[User]", "Optional[User]")
+            type_name: The Python type name (e.g., "User", "List[User]", "User | None")
 
         Returns:
             True if the type should use BaseSchema .from_dict() deserialization
@@ -138,14 +138,14 @@ class EndpointResponseHandlerGenerator:
         # Extract the base type name from complex types
         base_type = type_name
 
-        # Handle List[Type], Optional[Type], etc.
+        # Handle List[Type], Type | None, etc.
         if "[" in base_type and "]" in base_type:
-            # Extract the inner type from List[Type], Optional[Type], etc.
+            # Extract the inner type from List[Type], Type | None, etc.
             start_bracket = base_type.find("[")
             end_bracket = base_type.rfind("]")
             inner_type = base_type[start_bracket + 1 : end_bracket]
 
-            # For Union types like Optional[User] -> Union[User, None], take the first type
+            # For Union types like User | None -> Union[User, None], take the first type
             if ", " in inner_type:
                 inner_type = inner_type.split(", ")[0]
 
@@ -168,8 +168,9 @@ class EndpointResponseHandlerGenerator:
         }:
             return False
 
-        # Skip typing constructs (both uppercase and lowercase)
-        if base_type.startswith(("Dict[", "List[", "Optional[", "Union[", "Tuple[", "dict[", "list[", "tuple[")):
+        # Skip typing constructs
+        # Note: Modern Python 3.10+ uses | None instead of Optional[X]
+        if base_type.startswith(("dict[", "List[", "Union[", "Tuple[", "dict[", "list[", "tuple[")):
             return False
 
         # Check if this is a type alias (array or non-array) - these should NOT use BaseSchema
@@ -180,8 +181,7 @@ class EndpointResponseHandlerGenerator:
         # Check if it's a model type (contains a dot indicating it's from models package)
         # or if it's a simple class name that's likely a generated model (starts with uppercase)
         return "." in base_type or (
-            base_type[0].isupper()
-            and base_type not in {"Dict", "List", "Optional", "Union", "Tuple", "dict", "list", "tuple"}
+            base_type[0].isupper() and base_type not in {"Dict", "List", "Union", "Tuple", "dict", "list", "tuple"}
         )
 
     def _get_base_schema_deserialization_code(self, return_type: str, data_expr: str) -> str:
@@ -203,8 +203,29 @@ class EndpointResponseHandlerGenerator:
                 item_type = return_type[5:-1]  # Remove 'list[' and ']'
             return f"[{item_type}.from_dict(item) for item in {data_expr}]"
         elif return_type.startswith("Optional["):
-            # Handle Optional[Model] types
+            # SANITY CHECK: Unified type system should never produce Optional[X]
+            logger.error(
+                f"❌ ARCHITECTURE VIOLATION: Received legacy Optional[X] type in response handler: {return_type}. "
+                f"Unified type system must generate X | None directly."
+            )
+            # Defensive conversion (but this indicates a serious bug upstream)
             inner_type = return_type[9:-1]  # Remove 'Optional[' and ']'
+            logger.warning(f"⚠️ Converting to modern syntax internally for: {inner_type} | None")
+
+            # Check if inner type is also a list
+            if inner_type.startswith("List[") or inner_type.startswith("list["):
+                list_code = self._get_base_schema_deserialization_code(inner_type, data_expr)
+                return f"{list_code} if {data_expr} is not None else None"
+            else:
+                return f"{inner_type}.from_dict({data_expr}) if {data_expr} is not None else None"
+        elif " | None" in return_type or return_type.endswith("| None"):
+            # Handle Model | None types (modern Python 3.10+ syntax)
+            # Extract base type from "X | None" pattern
+            if " | None" in return_type:
+                inner_type = return_type.replace(" | None", "").strip()
+            else:
+                inner_type = return_type.replace("| None", "").strip()
+
             # Check if inner type is also a list
             if inner_type.startswith("List[") or inner_type.startswith("list["):
                 list_code = self._get_base_schema_deserialization_code(inner_type, data_expr)
@@ -230,7 +251,7 @@ class EndpointResponseHandlerGenerator:
         return_type: str,
         context: RenderContext,
         op: IROperation,
-        response_ir: Optional[IRResponse] = None,
+        response_ir: IRResponse | None = None,
     ) -> str:
         """Determines the code snippet to extract/transform the response body."""
         # Handle None, StreamingResponse, Iterator, etc.
@@ -243,7 +264,7 @@ class EndpointResponseHandlerGenerator:
             if return_type == "AsyncIterator[bytes]":
                 context.add_import(f"{context.core_package_name}.streaming_helpers", "iter_bytes")
                 return "iter_bytes(response)"
-            elif "Dict[str, Any]" in return_type or "dict" in return_type.lower():
+            elif "dict[str, Any]" in return_type or "dict" in return_type.lower():
                 # For event streams that return Dict objects
                 context.add_import(f"{context.core_package_name}.streaming_helpers", "iter_sse_events_text")
                 return "sse_json_stream_marker"  # Special marker handled by _write_parsed_return
@@ -260,7 +281,7 @@ class EndpointResponseHandlerGenerator:
                 return "iter_bytes(response)"
 
         # Special case for "data: Any" unwrapping when the actual schema has no fields/properties
-        if return_type in {"Dict[str, Any]", "Dict[str, object]", "object", "Any"}:
+        if return_type in {"dict[str, Any]", "dict[str, object]", "object", "Any"}:
             context.add_import("typing", "Dict")
             context.add_import("typing", "Any")
 
@@ -273,7 +294,7 @@ class EndpointResponseHandlerGenerator:
             return "response.json()  # Type is Any"
         elif return_type == "None":
             return "None"  # This will be handled by generate_response_handling directly
-        else:  # Includes schema-defined models, List[], Dict[], Optional[]
+        else:  # Includes schema-defined models, List[], dict[], Optional[]
             context.add_typing_imports_for_type(return_type)  # Ensure model itself is imported
 
             # Check if we should use BaseSchema deserialization instead of cast()
@@ -434,7 +455,7 @@ class EndpointResponseHandlerGenerator:
             context.add_import("typing", "cast")
             writer.write_line(f"return cast({strategy.return_type}, response.json())")
 
-    def _get_response_schema(self, response_ir: IRResponse) -> Optional[IRSchema]:
+    def _get_response_schema(self, response_ir: IRResponse) -> IRSchema | None:
         """Extract the schema from a response IR."""
         if not response_ir.content:
             return None

pyopenapi_gen/visit/endpoint/generators/signature_generator.py

@@ -5,7 +5,7 @@ Helper class for generating the method signature for an endpoint.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, List
 
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
@@ -24,15 +24,15 @@ logger = logging.getLogger(__name__)
 class EndpointMethodSignatureGenerator:
     """Generates the Python method signature for an endpoint operation."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def generate_signature(
         self,
         writer: CodeWriter,
         op: IROperation,
         context: RenderContext,
-        ordered_params: List[Dict[str, Any]],
+        ordered_params: List[dict[str, Any]],
         strategy: ResponseStrategy,
     ) -> None:
         """Writes the method signature to the provided CodeWriter."""

pyopenapi_gen/visit/endpoint/generators/url_args_generator.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import logging
 import re  # For _build_url_with_path_vars
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, List
 
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
@@ -21,8 +21,8 @@ logger = logging.getLogger(__name__)
 class EndpointUrlArgsGenerator:
     """Generates URL, query, and header parameters for an endpoint method."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def _build_url_with_path_vars(self, path: str) -> str:
         """Builds the f-string for URL construction, substituting path variables."""
@@ -34,7 +34,7 @@ class EndpointUrlArgsGenerator:
         return f'f"{{self.base_url}}{formatted_path}"'
 
     def _write_query_params(
-        self, writer: CodeWriter, op: IROperation, ordered_params: List[Dict[str, Any]], context: RenderContext
+        self, writer: CodeWriter, op: IROperation, ordered_params: List[dict[str, Any]], context: RenderContext
     ) -> None:
         """Writes query parameter dictionary construction."""
         # Logic from EndpointMethodGenerator._write_query_params
@@ -58,7 +58,7 @@ class EndpointUrlArgsGenerator:
                 )
 
     def _write_header_params(
-        self, writer: CodeWriter, op: IROperation, ordered_params: List[Dict[str, Any]], context: RenderContext
+        self, writer: CodeWriter, op: IROperation, ordered_params: List[dict[str, Any]], context: RenderContext
     ) -> None:
         """Writes header parameter dictionary construction."""
         # Logic from EndpointMethodGenerator._write_header_params
@@ -89,9 +89,9 @@ class EndpointUrlArgsGenerator:
         writer: CodeWriter,
         op: IROperation,
         context: RenderContext,
-        ordered_params: List[Dict[str, Any]],
-        primary_content_type: Optional[str],
-        resolved_body_type: Optional[str],
+        ordered_params: List[dict[str, Any]],
+        primary_content_type: str | None,
+        resolved_body_type: str | None,
     ) -> bool:
         """Writes URL, query, and header parameters. Returns True if header params were written."""
         # Main logic from EndpointMethodGenerator._write_url_and_args
@@ -103,9 +103,9 @@ class EndpointUrlArgsGenerator:
         # Check if any parameter in ordered_params is a query param, not just op.parameters
         has_spec_query_params = any(p.get("param_in") == "query" for p in ordered_params)
         if has_spec_query_params:
-            context.add_import("typing", "Any")  # For Dict[str, Any]
-            context.add_import("typing", "Dict")  # For Dict[str, Any]
-            writer.write_line("params: Dict[str, Any] = {")
+            context.add_import("typing", "Any")  # For dict[str, Any]
+            context.add_import("typing", "Dict")  # For dict[str, Any]
+            writer.write_line("params: dict[str, Any] = {")
             # writer.indent() # Indentation should be handled by CodeWriter when writing lines
             self._write_query_params(writer, op, ordered_params, context)
             # writer.dedent()
@@ -115,9 +115,9 @@ class EndpointUrlArgsGenerator:
         # Header Parameters
         has_header_params = any(p.get("param_in") == "header" for p in ordered_params)
         if has_header_params:
-            context.add_import("typing", "Any")  # For Dict[str, Any]
-            context.add_import("typing", "Dict")  # For Dict[str, Any]
-            writer.write_line("headers: Dict[str, Any] = {")
+            context.add_import("typing", "Any")  # For dict[str, Any]
+            context.add_import("typing", "Dict")  # For dict[str, Any]
+            writer.write_line("headers: dict[str, Any] = {")
             # writer.indent()
             self._write_header_params(writer, op, ordered_params, context)
             # writer.dedent()
@@ -160,11 +160,11 @@ class EndpointUrlArgsGenerator:
                     context.add_import("typing", "IO")  # For IO[Any]
                     context.add_import("typing", "Any")
                     writer.write_line(
-                        "files_data: Dict[str, IO[Any]] = DataclassSerializer.serialize(files)  # type failed"
+                        "files_data: dict[str, IO[Any]] = DataclassSerializer.serialize(files)  # type failed"
                     )
             elif primary_content_type == "application/x-www-form-urlencoded":
                 # form_data is the expected parameter name from EndpointParameterProcessor
-                # resolved_body_type should be Dict[str, Any]
+                # resolved_body_type should be dict[str, Any]
                 if resolved_body_type:
                     writer.write_line(
                         f"form_data_body: {resolved_body_type} = DataclassSerializer.serialize(form_data)"
@@ -173,7 +173,7 @@ class EndpointUrlArgsGenerator:
                     context.add_import("typing", "Dict")
                     context.add_import("typing", "Any")
                     writer.write_line(
-                        "form_data_body: Dict[str, Any] = DataclassSerializer.serialize(form_data)  # Fallback type"
+                        "form_data_body: dict[str, Any] = DataclassSerializer.serialize(form_data)  # Fallback type"
                     )
             elif resolved_body_type == "bytes":  # e.g. application/octet-stream
                 # bytes_content is the expected parameter name from EndpointParameterProcessor

pyopenapi_gen/visit/endpoint/processors/import_analyzer.py

@@ -5,7 +5,7 @@ Helper class for analyzing an IROperation and registering necessary imports.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Optional  # IO for multipart type hint
+from typing import TYPE_CHECKING, Any  # IO for multipart type hint
 
 # Necessary helpers for type analysis
 from pyopenapi_gen.helpers.endpoint_utils import (
@@ -24,8 +24,8 @@ logger = logging.getLogger(__name__)
 class EndpointImportAnalyzer:
     """Analyzes an IROperation to determine and register required imports."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def analyze_and_register_imports(
         self,
@@ -40,21 +40,21 @@ class EndpointImportAnalyzer:
 
         if op.request_body:
             content_types = op.request_body.content.keys()
-            body_param_type: Optional[str] = None
+            body_param_type: str | None = None
             if "multipart/form-data" in content_types:
-                # Type for multipart is Dict[str, IO[Any]] which requires IO and Any
+                # Type for multipart is dict[str, IO[Any]] which requires IO and Any
                 context.add_import("typing", "Dict")
                 context.add_import("typing", "IO")
                 context.add_import("typing", "Any")
-                # The actual type string "Dict[str, IO[Any]]" will be handled by add_typing_imports_for_type if passed
+                # The actual type string "dict[str, IO[Any]]" will be handled by add_typing_imports_for_type if passed
                 # but ensuring components are imported is key.
-                body_param_type = "Dict[str, IO[Any]]"
+                body_param_type = "dict[str, IO[Any]]"
             elif "application/json" in content_types:
                 body_param_type = get_request_body_type(op.request_body, context, self.schemas)
             elif "application/x-www-form-urlencoded" in content_types:
                 context.add_import("typing", "Dict")
                 context.add_import("typing", "Any")
-                body_param_type = "Dict[str, Any]"
+                body_param_type = "dict[str, Any]"
             elif content_types:  # Fallback for other types like application/octet-stream
                 body_param_type = "bytes"
 

pyopenapi_gen/visit/endpoint/processors/parameter_processor.py

@@ -5,7 +5,7 @@ Helper class for processing parameters for an endpoint method.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, List, Tuple
 
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.helpers.endpoint_utils import get_param_type, get_request_body_type
@@ -24,12 +24,12 @@ class EndpointParameterProcessor:
     method parameters for the endpoint signature and further processing.
     """
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def process_parameters(
         self, op: IROperation, context: RenderContext
-    ) -> Tuple[List[Dict[str, Any]], Optional[str], Optional[str]]:
+    ) -> Tuple[List[dict[str, Any]], str | None, str | None]:
         """
         Prepares and orders parameters for an endpoint method, including path,
         query, header, and request body parameters.
@@ -40,8 +40,8 @@ class EndpointParameterProcessor:
             - primary_content_type: The dominant content type for the request body.
             - resolved_body_type: The Python type hint for the request body.
         """
-        ordered_params: List[Dict[str, Any]] = []
-        param_details_map: Dict[str, Dict[str, Any]] = {}
+        ordered_params: List[dict[str, Any]] = []
+        param_details_map: dict[str, dict[str, Any]] = {}
 
         for param in op.parameters:
             param_name_sanitized = NameSanitizer.sanitize_method_name(param.name)
@@ -56,21 +56,21 @@ class EndpointParameterProcessor:
             ordered_params.append(param_info)
             param_details_map[param_name_sanitized] = param_info
 
-        primary_content_type: Optional[str] = None
-        resolved_body_type: Optional[str] = None
+        primary_content_type: str | None = None
+        resolved_body_type: str | None = None
 
         if op.request_body:
             content_types = op.request_body.content.keys()
             body_param_name = "body"  # Default name
             context.add_import("typing", "Any")  # General fallback
-            body_specific_param_info: Optional[Dict[str, Any]] = None
+            body_specific_param_info: dict[str, Any] | None = None
 
             if "multipart/form-data" in content_types:
                 primary_content_type = "multipart/form-data"
                 body_param_name = "files"
                 context.add_import("typing", "Dict")
                 context.add_import("typing", "IO")
-                resolved_body_type = "Dict[str, IO[Any]]"
+                resolved_body_type = "dict[str, IO[Any]]"
                 body_specific_param_info = {
                     "name": body_param_name,
                     "type": resolved_body_type,
@@ -95,7 +95,7 @@ class EndpointParameterProcessor:
                 primary_content_type = "application/x-www-form-urlencoded"
                 body_param_name = "form_data"
                 context.add_import("typing", "Dict")
-                resolved_body_type = "Dict[str, Any]"
+                resolved_body_type = "dict[str, Any]"
                 body_specific_param_info = {
                     "name": body_param_name,
                     "type": resolved_body_type,
@@ -138,8 +138,8 @@ class EndpointParameterProcessor:
         return final_ordered_params, primary_content_type, resolved_body_type
 
     def _ensure_path_variables_as_params(
-        self, op: IROperation, current_params: List[Dict[str, Any]], param_details_map: Dict[str, Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
+        self, op: IROperation, current_params: List[dict[str, Any]], param_details_map: dict[str, dict[str, Any]]
+    ) -> List[dict[str, Any]]:
         """
         Ensures that all variables in the URL path are present in the list of parameters.
         If a path variable is not already defined as a parameter, it's added as a required string type.

pyopenapi_gen/visit/model/alias_generator.py

@@ -3,13 +3,11 @@ Generates Python code for type aliases from IRSchema objects.
 """
 
 import logging
-from typing import Dict, Optional
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.core.writers.python_construct_renderer import PythonConstructRenderer
-from pyopenapi_gen.helpers.type_resolution.finalizer import TypeFinalizer
 from pyopenapi_gen.types.services.type_service import UnifiedTypeService
 
 logger = logging.getLogger(__name__)
@@ -21,7 +19,7 @@ class AliasGenerator:
     def __init__(
         self,
         renderer: PythonConstructRenderer,
-        all_schemas: Optional[Dict[str, IRSchema]],
+        all_schemas: dict[str, IRSchema] | None,
     ):
         # Pre-condition
         if renderer is None:
@@ -70,7 +68,6 @@ class AliasGenerator:
 
         alias_name = NameSanitizer.sanitize_class_name(base_name)
         target_type = self.type_service.resolve_schema_type(schema, context, required=True, resolve_underlying=True)
-        target_type = TypeFinalizer(context)._clean_type(target_type)
 
         # logger.debug(f"AliasGenerator: Rendering alias '{alias_name}' for target type '{target_type}'.")