pyopenapi-gen 0.13.0__py3-none-any.whl → 0.14.1__py3-none-any.whl

pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py

@@ -5,8 +5,9 @@ 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
 from pyopenapi_gen.helpers.endpoint_utils import (
     _get_primary_response,
@@ -43,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:
         """
@@ -129,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
@@ -137,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]
 
@@ -167,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
@@ -179,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:
@@ -202,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)
@@ -229,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.
@@ -242,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
@@ -259,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")
 
@@ -272,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()
@@ -353,8 +375,8 @@ class EndpointResponseHandlerGenerator:
                         else:
                             writer.write_line("return None")
                 else:
-                    # Error responses
-                    error_class_name = f"Error{status_code_val}"
+                    # Error responses - use human-readable exception names
+                    error_class_name = get_exception_class_name(status_code_val)
                     context.add_import(f"{context.core_package_name}", error_class_name)
                     writer.write_line(f"raise {error_class_name}(response=response)")
 
@@ -433,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/exception_visitor.py

@@ -1,40 +1,78 @@
 from pyopenapi_gen import IRSpec
 
 from ..context.render_context import RenderContext
+from ..core.http_status_codes import (
+    get_exception_class_name,
+    get_status_name,
+    is_client_error,
+    is_error_code,
+    is_server_error,
+)
 from ..core.writers.python_construct_renderer import PythonConstructRenderer
 
 
 class ExceptionVisitor:
-    """Visitor for rendering exception alias classes from IRSpec."""
+    """Visitor for rendering exception alias classes from IRSpec.
+
+    This visitor generates exception classes only for error status codes (4xx and 5xx).
+    Success codes (2xx) are intentionally excluded as they represent successful responses.
+    """
 
     def __init__(self) -> None:
         self.renderer = PythonConstructRenderer()
 
-    def visit(self, spec: IRSpec, context: RenderContext) -> tuple[str, list[str]]:
-        # Register base exception imports
-        context.add_import(f"{context.core_package_name}.exceptions", "HTTPError")
+    def visit(self, spec: IRSpec, context: RenderContext) -> tuple[str, list[str], list[int]]:
+        """Generate exception classes from IRSpec.
+
+        Args:
+            spec: The IRSpec containing operations and responses
+            context: Render context for imports and code generation
+
+        Returns:
+            Tuple of (generated_code, exception_class_names, status_codes_list)
+        """
+        # Register base exception imports (only the ones we actually use)
+        # Note: HTTPError is not used in exception_aliases.py, so we don't import it
+        context.add_import("httpx", "Response")  # Third-party import first (Ruff I001)
         context.add_import(f"{context.core_package_name}.exceptions", "ClientError")
         context.add_import(f"{context.core_package_name}.exceptions", "ServerError")
-        context.add_import("httpx", "Response")
 
-        # Collect unique numeric status codes
-        codes = sorted(
-            {int(resp.status_code) for op in spec.operations for resp in op.responses if resp.status_code.isdigit()}
-        )
+        # Collect unique numeric error status codes (4xx and 5xx only)
+        all_codes = {
+            int(resp.status_code) for op in spec.operations for resp in op.responses if resp.status_code.isdigit()
+        }
+        error_codes = sorted([code for code in all_codes if is_error_code(code)])
 
         all_exception_code = []
         generated_alias_names = []
 
         # Use renderer to generate each exception class
-        for code in codes:
-            base_class = "ClientError" if code < 500 else "ServerError"
-            class_name = f"Error{code}"
+        for code in error_codes:
+            # Determine base class using helper functions
+            if is_client_error(code):
+                base_class = "ClientError"
+            elif is_server_error(code):
+                base_class = "ServerError"
+            else:
+                # Should not happen since we filtered to 4xx/5xx, but be defensive
+                continue
+
+            # Get human-readable exception class name (e.g., NotFoundError instead of Error404)
+            class_name = get_exception_class_name(code)
             generated_alias_names.append(class_name)
-            docstring = f"Exception alias for HTTP {code} responses."
+
+            # Get human-readable status name for documentation
+            status_name = get_status_name(code)
+            docstring = f"HTTP {code} {status_name}.\n\nRaised when the server responds with a {code} status code."
 
             # Define the __init__ method body
             init_method_body = [
                 "def __init__(self, response: Response) -> None:",
+                f'    """Initialise {class_name} with the HTTP response.',
+                "",  # Empty line without trailing whitespace (Ruff W293)
+                "    Args:",
+                "        response: The httpx Response object that triggered this exception",
+                '    """',
                 "    super().__init__(status_code=response.status_code, message=response.text, response=response)",
             ]
 
@@ -47,6 +85,6 @@ class ExceptionVisitor:
             )
             all_exception_code.append(exception_code)
 
-        # Join the generated class strings
-        final_code = "\n".join(all_exception_code)
-        return final_code, generated_alias_names
+        # Join the generated class strings with 2 blank lines between classes (PEP 8 / Ruff E302)
+        final_code = "\n\n\n".join(all_exception_code)
+        return final_code, generated_alias_names, error_codes

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}'.")