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

pyopenapi_gen/core/telemetry.py

@@ -8,7 +8,7 @@ usage telemetry for PyOpenAPI Generator. Telemetry is opt-in only.
 import json
 import os
 import time
-from typing import Any, Dict, Optional
+from typing import Any
 
 
 class TelemetryClient:
@@ -24,7 +24,7 @@ class TelemetryClient:
         enabled: Whether telemetry is currently enabled
     """
 
-    def __init__(self, enabled: Optional[bool] = None) -> None:
+    def __init__(self, enabled: bool | None = None) -> None:
         """
         Initialize a new TelemetryClient.
 
@@ -38,7 +38,7 @@ class TelemetryClient:
         else:
             self.enabled = enabled
 
-    def track_event(self, event: str, properties: Optional[Dict[str, Any]] = None) -> None:
+    def track_event(self, event: str, properties: dict[str, Any] | None = None) -> None:
         """
         Track a telemetry event if telemetry is enabled.
 
@@ -52,7 +52,7 @@ class TelemetryClient:
         if not self.enabled:
             return
 
-        data: Dict[str, Any] = {
+        data: dict[str, Any] = {
             "event": event,
             "properties": properties or {},
             "timestamp": time.time(),

pyopenapi_gen/core/utils.py

@@ -8,7 +8,7 @@ import keyword
 import logging
 import re
 from datetime import datetime
-from typing import Any, Dict, Set, Type, TypeVar, cast
+from typing import Any, Set, Type, TypeVar, cast
 
 logger = logging.getLogger(__name__)
 
@@ -228,7 +228,7 @@ class ParamSubstitutor:
     """Helper for rendering path templates with path parameters."""
 
     @staticmethod
-    def render_path(template: str, values: Dict[str, Any]) -> str:
+    def render_path(template: str, values: dict[str, Any]) -> str:
         """Replace placeholders in a URL path template using provided values."""
         rendered = template
         for key, val in values.items():
@@ -240,7 +240,7 @@ class KwargsBuilder:
     """Builder for assembling HTTP request keyword arguments."""
 
     def __init__(self) -> None:
-        self._kwargs: Dict[str, Any] = {}
+        self._kwargs: dict[str, Any] = {}
 
     def with_params(self, **params: Any) -> "KwargsBuilder":
         """Add query parameters, skipping None values."""
@@ -254,7 +254,7 @@ class KwargsBuilder:
         self._kwargs["json"] = body
         return self
 
-    def build(self) -> Dict[str, Any]:
+    def build(self) -> dict[str, Any]:
         """Return the assembled kwargs dictionary."""
         return self._kwargs
 
@@ -263,10 +263,10 @@ class Formatter:
     """Helper to format code using Black, falling back to unformatted content if Black is unavailable or errors."""
 
     def __init__(self) -> None:
-        from typing import Any, Callable, Optional
+        from typing import Any, Callable
 
-        self._file_mode: Optional[Any] = None
-        self._format_str: Optional[Callable[..., str]] = None
+        self._file_mode: Any | None = None
+        self._format_str: Callable[..., str] | None = None
         try:
             from black import FileMode, format_str
 

pyopenapi_gen/core/writers/code_writer.py

@@ -6,7 +6,7 @@ writing lines and blocks, and supporting wrapped output for code and docstrings.
 to be used by code generation visitors and emitters to ensure consistent, readable output.
 """
 
-from typing import List, Optional
+from typing import List
 
 from .line_writer import LineWriter
 
@@ -88,7 +88,7 @@ class CodeWriter:
         self.writer.max_width = old_width
 
     def write_function_signature(
-        self, name: str, args: List[str], return_type: Optional[str] = None, async_: bool = False
+        self, name: str, args: List[str], return_type: str | None = None, async_: bool = False
     ) -> None:
         """
         Write a function or method signature, with each argument on its own line and correct indentation.

pyopenapi_gen/core/writers/documentation_writer.py

@@ -6,7 +6,7 @@ for building comprehensive, type-rich docstrings for generated Python code. It s
 alignment, line wrapping, and section formatting for Args, Returns, and Raises.
 """
 
-from typing import List, Optional, Tuple, Union
+from typing import List, Tuple, Union
 
 from .line_writer import LineWriter
 
@@ -16,36 +16,36 @@ class DocumentationBlock:
     Data container for docstring content.
 
     Attributes:
-        summary (Optional[str]): The summary line for the docstring.
-        description (Optional[str]): The detailed description.
+        summary (str | None): The summary line for the docstring.
+        description (str | None): The detailed description.
         args (Optional[List[Union[Tuple[str, str, str], Tuple[str, str]]]]):
             List of arguments as (name, type, desc) or (type, desc) tuples.
-        returns (Optional[Tuple[str, str]]): The return type and description.
-        raises (Optional[List[Tuple[str, str]]]): List of (exception type, description) tuples.
+        returns (Tuple[str, str] | None): The return type and description.
+        raises (List[Tuple[str, str]] | None): List of (exception type, description) tuples.
     """
 
     def __init__(
         self,
-        summary: Optional[str] = None,
-        description: Optional[str] = None,
-        args: Optional[List[Union[Tuple[str, str, str], Tuple[str, str]]]] = None,
-        returns: Optional[Tuple[str, str]] = None,
-        raises: Optional[List[Tuple[str, str]]] = None,
+        summary: str | None = None,
+        description: str | None = None,
+        args: List[Union[Tuple[str, str, str], Tuple[str, str]]] | None = None,
+        returns: Tuple[str, str] | None = None,
+        raises: List[Tuple[str, str]] | None = None,
     ) -> None:
         """
         Initialize a DocumentationBlock.
 
         Args:
-            summary (Optional[str]): The summary line.
-            description (Optional[str]): The detailed description.
+            summary (str | None): The summary line.
+            description (str | None): The detailed description.
             args (Optional[List[Union[Tuple[str, str, str], Tuple[str, str]]]]): Arguments.
-            returns (Optional[Tuple[str, str]]): Return type and description.
-            raises (Optional[List[Tuple[str, str]]]): Exceptions.
+            returns (Tuple[str, str] | None): Return type and description.
+            raises (List[Tuple[str, str]] | None): Exceptions.
         """
-        self.summary: Optional[str] = summary
-        self.description: Optional[str] = description
+        self.summary: str | None = summary
+        self.description: str | None = description
         self.args: List[Union[Tuple[str, str, str], Tuple[str, str]]] = args or []
-        self.returns: Optional[Tuple[str, str]] = returns
+        self.returns: Tuple[str, str] | None = returns
         self.raises: List[Tuple[str, str]] = raises or []
 
 
@@ -58,7 +58,7 @@ class DocumentationFormatter:
         self.width: int = width
         self.min_desc_col: int = min_desc_col
 
-    def wrap(self, text: str, indent: int, prefix: Optional[str] = None) -> List[str]:
+    def wrap(self, text: str, indent: int, prefix: str | None = None) -> List[str]:
         if not text:
             return []
         writer = LineWriter(max_width=self.width)

pyopenapi_gen/core/writers/line_writer.py

@@ -5,7 +5,7 @@ This class is designed for use in both code and documentation generation, provid
 new lines, and query the current line's width.
 """
 
-from typing import List, Optional
+from typing import List
 
 
 class LineWriter:
@@ -169,7 +169,7 @@ class LineWriter:
             self.lines[-1] += " " * (col - current - 1)
         # If already at or past col, do nothing
 
-    def append_wrapped_at_column(self, text: str, width: int, col: Optional[int] = None) -> None:
+    def append_wrapped_at_column(self, text: str, width: int, col: int | None = None) -> None:
         """
         Append text, wrapping as needed, so that the first line continues from the current position,
         and all subsequent lines start at column `col`.
@@ -180,7 +180,7 @@ class LineWriter:
         Args:
             text (str)          : The text to append and wrap.
             width (int)         : The maximum line width.
-            col (Optional[int]) : The column at which to start wrapped lines. If None, uses current
+            col (int | None) : The column at which to start wrapped lines. If None, uses current
                                   line width.
         """
         import textwrap

pyopenapi_gen/core/writers/python_construct_renderer.py

@@ -7,7 +7,7 @@ It handles all the details of formatting, import registration, and docstring gen
 for these constructs.
 """
 
-from typing import Dict, List, Optional, Tuple
+from typing import List, Tuple
 
 from pyopenapi_gen.context.render_context import RenderContext
 
@@ -35,7 +35,7 @@ class PythonConstructRenderer:
         self,
         alias_name: str,
         target_type: str,
-        description: Optional[str],
+        description: str | None,
         context: RenderContext,
     ) -> str:
         """
@@ -80,7 +80,7 @@ class PythonConstructRenderer:
         enum_name: str,
         base_type: str,  # 'str' or 'int'
         values: List[Tuple[str, str | int]],  # List of (MEMBER_NAME, value)
-        description: Optional[str],
+        description: str | None,
         context: RenderContext,
     ) -> str:
         """
@@ -143,10 +143,10 @@ class PythonConstructRenderer:
     def render_dataclass(
         self,
         class_name: str,
-        fields: List[Tuple[str, str, Optional[str], Optional[str]]],  # name, type_hint, default_expr, description
-        description: Optional[str],
+        fields: List[Tuple[str, str, str | None, str | None]],  # name, type_hint, default_expr, description
+        description: str | None,
         context: RenderContext,
-        field_mappings: Optional[Dict[str, str]] = None,
+        field_mappings: dict[str, str] | None = None,
     ) -> str:
         """
         Render a dataclass as Python code with BaseSchema support.
@@ -168,7 +168,7 @@ class PythonConstructRenderer:
                 \"\"\"User information with automatic JSON field mapping.\"\"\"
                 id_: str
                 first_name: str
-                email: Optional[str] = None
+                email: str | None = None
                 is_active: bool = True
 
                 class Meta:
@@ -274,9 +274,9 @@ class PythonConstructRenderer:
     def render_class(
         self,
         class_name: str,
-        base_classes: Optional[List[str]],
-        docstring: Optional[str],
-        body_lines: Optional[List[str]],
+        base_classes: List[str] | None,
+        docstring: str | None,
+        body_lines: List[str] | None,
         context: RenderContext,
     ) -> str:
         """

pyopenapi_gen/emit/models_emitter.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import List, Optional
+from typing import List
 
 from pyopenapi_gen.context.render_context import RenderContext
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -20,7 +20,7 @@ class ModelsEmitter:
         # self.writer an instance CodeWriter() here seems unused globally for this emitter.
         # Each file generation part either writes directly or uses a local CodeWriter.
 
-    def _generate_model_file(self, schema_ir: IRSchema, models_dir: Path) -> Optional[str]:
+    def _generate_model_file(self, schema_ir: IRSchema, models_dir: Path) -> str | None:
         """Generates a single Python file for a given IRSchema. Returns file path if generated."""
         if not schema_ir.name:
             logger.warning(f"Skipping model generation for schema without a name: {schema_ir}")

pyopenapi_gen/emitters/core_emitter.py

@@ -1,6 +1,6 @@
 import importlib.resources
 import os
-from typing import List, Optional
+from typing import List
 
 from pyopenapi_gen.context.file_manager import FileManager
 
@@ -22,12 +22,10 @@ CORE_README_TEMPLATE_FILENAME = "README.md"
 
 CONFIG_TEMPLATE = """
 from dataclasses import dataclass
-from typing import Optional
-
 @dataclass
 class ClientConfig:
     base_url: str
-    timeout: Optional[float] = 30.0
+    timeout: float | None = 30.0
 """
 
 
@@ -35,7 +33,7 @@ class CoreEmitter:
     """Copies all required runtime files into the generated core module."""
 
     def __init__(
-        self, core_dir: str = "core", core_package: str = "core", exception_alias_names: Optional[List[str]] = None
+        self, core_dir: str = "core", core_package: str = "core", exception_alias_names: List[str] | None = None
     ):
         # core_dir is the relative path WITHIN the output package, e.g., "core" or "shared/core"
         # core_package is the Python import name, e.g., "core" or "shared.core"

pyopenapi_gen/emitters/endpoints_emitter.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import List, Tuple
 
 from pyopenapi_gen import IROperation, IRParameter, IRRequestBody
 from pyopenapi_gen.context.render_context import RenderContext
@@ -17,7 +17,7 @@ PARAM_TYPE_MAPPING = {
     "boolean": "bool",
     "string": "str",
     "array": "List",
-    "object": "Dict[str, Any]",
+    "object": "dict[str, Any]",
 }
 # Format-specific overrides
 PARAM_FORMAT_MAPPING = {
@@ -47,7 +47,7 @@ def schema_to_type(schema: IRParameter) -> str:
     # Array handling
     elif s.type == "array" and s.items:
         # For array items, we recursively call schema_to_type.
-        # The nullability of the item_type itself (e.g. List[Optional[int]])
+        # The nullability of the item_type itself (e.g. List[int | None])
         # will be handled by the recursive call based on s.items.is_nullable.
         item_schema_as_param = IRParameter(name="_item", param_in="_internal", required=False, schema=s.items)
         item_type_str = schema_to_type(item_schema_as_param)
@@ -70,8 +70,8 @@ def schema_to_type(schema: IRParameter) -> str:
     # 2. Apply nullability based on IRSchema's is_nullable field
     # This s.is_nullable should be the source of truth from the IR after parsing.
     if s.is_nullable:
-        # Ensure "Any" also gets wrapped, e.g. Optional[Any]
-        py_type = f"Optional[{py_type}]"
+        # Ensure "Any" also gets wrapped, e.g. Any | None
+        py_type = f"{py_type} | None"
 
     return py_type
 
@@ -82,7 +82,7 @@ def _get_request_body_type(body: IRRequestBody) -> str:
         if "json" in mt.lower():
             return schema_to_type(IRParameter(name="body", param_in="body", required=body.required, schema=sch))
     # Fallback to generic dict
-    return "Dict[str, Any]"
+    return "dict[str, Any]"
 
 
 def _deduplicate_tag_clients(client_classes: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
@@ -106,7 +106,7 @@ class EndpointsEmitter:
     def __init__(self, context: RenderContext) -> None:
         self.context = context
         self.formatter = Formatter()
-        self.visitor: Optional[EndpointVisitor] = None
+        self.visitor: EndpointVisitor | None = None
 
     def _deduplicate_operation_ids(self, operations: List[IROperation]) -> None:
         """
@@ -115,7 +115,7 @@ class EndpointsEmitter:
         Args:
             operations: List of operations for a single tag.
         """
-        seen_methods: Dict[str, int] = {}
+        seen_methods: dict[str, int] = {}
         for op in operations:
             method_name = NameSanitizer.sanitize_method_name(op.operation_id)
             if method_name in seen_methods:
@@ -144,7 +144,7 @@ class EndpointsEmitter:
                 self.context.file_manager.write_file(str(file_path), content)
 
         # Ensure parsed_schemas is at least an empty dict if None,
-        # as EndpointVisitor expects Dict[str, IRSchema]
+        # as EndpointVisitor expects dict[str, IRSchema]
         current_parsed_schemas = self.context.parsed_schemas
         if current_parsed_schemas is None:
             logger.warning(
@@ -156,8 +156,8 @@ class EndpointsEmitter:
         if self.visitor is None:
             self.visitor = EndpointVisitor(current_parsed_schemas)  # Pass the (potentially defaulted) dict
 
-        tag_key_to_ops: Dict[str, List[IROperation]] = {}
-        tag_key_to_candidates: Dict[str, List[str]] = {}
+        tag_key_to_ops: dict[str, List[IROperation]] = {}
+        tag_key_to_candidates: dict[str, List[str]] = {}
         for op in operations:
             tags = op.tags or [DEFAULT_TAG]
             for tag in tags:
@@ -175,7 +175,7 @@ class EndpointsEmitter:
             upper = sum(1 for c in t if c.isupper())
             return (is_pascal, word_count, upper, t)
 
-        tag_map: Dict[str, str] = {}
+        tag_map: dict[str, str] = {}
         for key, candidates in tag_key_to_candidates.items():
             best_tag_for_key = DEFAULT_TAG  # Default if no candidates somehow
             if candidates:

pyopenapi_gen/emitters/exceptions_emitter.py

@@ -1,7 +1,6 @@
 import json
 import os
 from pathlib import Path
-from typing import Optional
 
 from pyopenapi_gen import IRSpec
 from pyopenapi_gen.context.render_context import RenderContext
@@ -22,13 +21,13 @@ class ExceptionsEmitter:
     exceptions are available.
     """
 
-    def __init__(self, core_package_name: str = "core", overall_project_root: Optional[str] = None) -> None:
+    def __init__(self, core_package_name: str = "core", overall_project_root: str | None = None) -> None:
         self.visitor = ExceptionVisitor()
         self.core_package_name = core_package_name
         self.overall_project_root = overall_project_root
 
     def emit(
-        self, spec: IRSpec, output_dir: str, client_package_name: Optional[str] = None
+        self, spec: IRSpec, output_dir: str, client_package_name: str | None = None
     ) -> tuple[list[str], list[str]]:
         """Generate exception aliases for the given spec.
 
@@ -61,6 +60,8 @@ class ExceptionsEmitter:
 
         generated_imports = context.render_imports()
 
+        alias_names.sort()
+
         # Add __all__ list with proper spacing (2 blank lines after last class - Ruff E305)
         if alias_names:
             all_list_str = ", ".join([f'"{name}"' for name in alias_names])

pyopenapi_gen/emitters/models_emitter.py

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional, Set
+from typing import List, Set
 
 from pyopenapi_gen import IRSchema, IRSpec
 from pyopenapi_gen.context.render_context import RenderContext
@@ -22,15 +22,15 @@ class ModelsEmitter:
     Handles creation of __init__.py and py.typed files.
     """
 
-    def __init__(self, context: RenderContext, parsed_schemas: Dict[str, IRSchema]):
+    def __init__(self, context: RenderContext, parsed_schemas: dict[str, IRSchema]):
         self.context: RenderContext = context
         # Store a reference to the schemas that were passed in.
         # These schemas will have their .generation_name and .final_module_stem updated.
-        self.parsed_schemas: Dict[str, IRSchema] = parsed_schemas
+        self.parsed_schemas: dict[str, IRSchema] = parsed_schemas
         self.import_collector = self.context.import_collector
         self.writer = CodeWriter()
 
-    def _generate_model_file(self, schema_ir: IRSchema, models_dir: Path) -> Optional[str]:
+    def _generate_model_file(self, schema_ir: IRSchema, models_dir: Path) -> str | None:
         """Generates a single Python file for a given IRSchema."""
         if not schema_ir.name:  # Original name, used for logging/initial identification
             logger.warning(f"Skipping model generation for schema without an original name: {schema_ir}")
@@ -168,7 +168,7 @@ class ModelsEmitter:
         generated_content = init_writer.get_code()
         return generated_content
 
-    def emit(self, spec: IRSpec, output_root: str) -> Dict[str, List[str]]:
+    def emit(self, spec: IRSpec, output_root: str) -> dict[str, List[str]]:
         """Emits all model files derived from IR schemas.
 
         Contracts:
@@ -352,7 +352,7 @@ class ModelsEmitter:
 
                 # Fetch the schema_ir object using the key from all_schemas_for_generation
                 # This ensures we are working with the potentially newly created & named schemas.
-                current_schema_ir_obj: Optional[IRSchema] = all_schemas_for_generation.get(schema_key)
+                current_schema_ir_obj: IRSchema | None = all_schemas_for_generation.get(schema_key)
 
                 if not current_schema_ir_obj:
                     logger.warning(f"Schema key '{schema_key}' from all_schemas_for_generation not found. Skipping.")

pyopenapi_gen/generator/client_generator.py

@@ -9,7 +9,7 @@ import tempfile
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Any, Dict, List, Optional
+from typing import Any, List
 
 from pyopenapi_gen.context.render_context import RenderContext
 from pyopenapi_gen.core.loader.loader import load_ir_from_spec
@@ -47,9 +47,9 @@ class ClientGenerator:
         """
         self.verbose = verbose
         self.start_time = time.time()
-        self.timings: Dict[str, float] = {}
+        self.timings: dict[str, float] = {}
 
-    def _log_progress(self, message: str, stage: Optional[str] = None) -> None:
+    def _log_progress(self, message: str, stage: str | None = None) -> None:
         """
         Log a progress message with timestamp.
 
@@ -89,7 +89,7 @@ class ClientGenerator:
         output_package: str,
         force: bool = False,
         no_postprocess: bool = False,
-        core_package: Optional[str] = None,
+        core_package: str | None = None,
     ) -> List[Path]:
         """
         Generate the client code from the OpenAPI spec.
@@ -99,10 +99,10 @@ class ClientGenerator:
             project_root (Path): Path to the root of the Python project (absolute or relative).
             output_package (str): Python package path for the generated client (e.g., 'pyapis.my_api_client').
             force (bool): Overwrite output without diff check.
-            name (Optional[str]): Custom client package name (not used).
+            name (str | None): Custom client package name (not used).
             docs (bool): Kept for interface compatibility.
             telemetry (bool): Kept for interface compatibility.
-            auth (Optional[str]): Kept for interface compatibility.
+            auth (str | None): Kept for interface compatibility.
             no_postprocess (bool): Skip post-processing (type checking, etc.).
             core_package (str): Python package path for the core package.
 

pyopenapi_gen/helpers/endpoint_utils.py

@@ -5,7 +5,7 @@ Used by EndpointVisitor and related emitters.
 
 import logging
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any, List
 
 from pyopenapi_gen import IROperation, IRParameter, IRRequestBody, IRResponse, IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
@@ -17,7 +17,7 @@ from ..types.services.type_service import UnifiedTypeService
 logger = logging.getLogger(__name__)
 
 
-def get_params(op: IROperation, context: RenderContext, schemas: Dict[str, IRSchema]) -> List[Dict[str, Any]]:
+def get_params(op: IROperation, context: RenderContext, schemas: dict[str, IRSchema]) -> List[dict[str, Any]]:
     """
     Returns a list of dicts with name, type, default, and required for template rendering.
     Requires the full schema dictionary for type resolution.
@@ -37,7 +37,7 @@ def get_params(op: IROperation, context: RenderContext, schemas: Dict[str, IRSch
     return params
 
 
-def get_param_type(param: IRParameter, context: RenderContext, schemas: Dict[str, IRSchema]) -> str:
+def get_param_type(param: IRParameter, context: RenderContext, schemas: dict[str, IRSchema]) -> str:
     """Returns the Python type hint for a parameter, resolving references using the schemas dict."""
     # Use unified service for type resolution
     type_service = UnifiedTypeService(schemas)
@@ -59,7 +59,7 @@ def get_param_type(param: IRParameter, context: RenderContext, schemas: Dict[str
     return py_type
 
 
-def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas: Dict[str, IRSchema]) -> str:
+def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas: dict[str, IRSchema]) -> str:
     """Returns the Python type hint for a request body, resolving references using the schemas dict."""
     # Prefer application/json schema if available
     json_schema = body.content.get("application/json")
@@ -70,11 +70,11 @@ def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas:
         if py_type.startswith(".") and not py_type.startswith(".."):
             py_type = "models" + py_type
 
-        # If the resolved type is 'Any' for a JSON body, default to Dict[str, Any]
+        # If the resolved type is 'Any' for a JSON body, default to dict[str, Any]
         if py_type == "Any":
             context.add_import("typing", "Dict")
             # context.add_import("typing", "Any") # Already added by the fallback or TypeHelper
-            return "Dict[str, Any]"
+            return "dict[str, Any]"
         return py_type
     # Fallback for other content types (e.g., octet-stream)
     # TODO: Handle other types more specifically if needed
@@ -89,7 +89,7 @@ def get_request_body_type(body: IRRequestBody, context: RenderContext, schemas:
 def get_return_type(
     op: IROperation,
     context: RenderContext,
-    schemas: Dict[str, IRSchema],
+    schemas: dict[str, IRSchema],
 ) -> tuple[str | None, bool]:
     """
     DEPRECATED: Use get_return_type_unified instead.
@@ -136,7 +136,7 @@ def get_return_type(
     return (py_type, False)
 
 
-def _get_primary_response(op: IROperation) -> Optional[IRResponse]:
+def _get_primary_response(op: IROperation) -> IRResponse | None:
     """Helper to find the best primary success response."""
     resp = None
     # Prioritize 200, 201, 202, 204
@@ -158,7 +158,7 @@ def _get_primary_response(op: IROperation) -> Optional[IRResponse]:
     return None
 
 
-def _get_response_schema_and_content_type(resp: IRResponse) -> tuple[Optional[IRSchema], Optional[str]]:
+def _get_response_schema_and_content_type(resp: IRResponse) -> tuple[IRSchema | None, str | None]:
     """Helper to get the schema and content type from a response."""
     if not resp.content:
         return None, None
@@ -179,7 +179,7 @@ def _get_response_schema_and_content_type(resp: IRResponse) -> tuple[Optional[IR
     return resp.content.get(mt), mt
 
 
-def _find_resource_schema(update_schema_name: str, schemas: Dict[str, IRSchema]) -> Optional[IRSchema]:
+def _find_resource_schema(update_schema_name: str, schemas: dict[str, IRSchema]) -> IRSchema | None:
     """
     Given an update schema name (e.g. 'TenantUpdate'), try to find the corresponding
     resource schema (e.g. 'Tenant') in the schemas dictionary.
@@ -205,7 +205,7 @@ def _find_resource_schema(update_schema_name: str, schemas: Dict[str, IRSchema])
     return None
 
 
-def _infer_type_from_path(path: str, schemas: Dict[str, IRSchema]) -> Optional[IRSchema]:
+def _infer_type_from_path(path: str, schemas: dict[str, IRSchema]) -> IRSchema | None:
     """
     Infers a response type from a path. This is used when a response schema is not specified.
 
@@ -350,8 +350,8 @@ def merge_params_with_model_fields(
     op: IROperation,
     model_schema: IRSchema,
     context: RenderContext,
-    schemas: Dict[str, IRSchema],
-) -> List[Dict[str, Any]]:
+    schemas: dict[str, IRSchema],
+) -> List[dict[str, Any]]:
     """
     Merge endpoint parameters with required model fields for function signatures.
     - Ensures all required model fields are present as parameters (without duplication).
@@ -484,7 +484,7 @@ def get_type_for_specific_response(
         ctx.add_import("typing", "AsyncIterator")
         ctx.add_import("typing", "Dict")
         ctx.add_import("typing", "Any")
-        return "AsyncIterator[Dict[str, Any]]"
+        return "AsyncIterator[dict[str, Any]]"
 
     return final_py_type
 
@@ -504,9 +504,7 @@ def _is_binary_stream_content(resp_ir: IRResponse) -> bool:
     )
 
 
-def _get_item_type_from_schema(
-    resp_ir: IRResponse, all_schemas: dict[str, IRSchema], ctx: RenderContext
-) -> Optional[str]:
+def _get_item_type_from_schema(resp_ir: IRResponse, all_schemas: dict[str, IRSchema], ctx: RenderContext) -> str | None:
     """Extract item type from schema for streaming responses."""
     schema, _ = _get_response_schema_and_content_type(resp_ir)
     if not schema:
@@ -528,7 +526,7 @@ def get_python_type_for_response_body(resp_ir: IRResponse, all_schemas: dict[str
     return type_service.resolve_schema_type(schema, ctx, required=True)
 
 
-def get_schema_from_response(resp_ir: IRResponse, all_schemas: dict[str, IRSchema]) -> Optional[IRSchema]:
+def get_schema_from_response(resp_ir: IRResponse, all_schemas: dict[str, IRSchema]) -> IRSchema | None:
     """Get the schema from a response object."""
     schema, _ = _get_response_schema_and_content_type(resp_ir)
     return schema