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

pyopenapi_gen/cli.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Union
 
 import typer
 import yaml
@@ -7,7 +7,7 @@ import yaml
 from .generator.client_generator import ClientGenerator, GenerationError
 
 
-def _load_spec(path_or_url: str) -> Union[Dict[str, Any], Any]:
+def _load_spec(path_or_url: str) -> Union[dict[str, Any], Any]:
     """Load a spec from a file path or URL."""
     if Path(path_or_url).exists():
         return yaml.safe_load(Path(path_or_url).read_text())
@@ -30,7 +30,7 @@ def main(
     ),
     force: bool = typer.Option(False, "-f", "--force", help="Overwrite without diff check"),
     no_postprocess: bool = typer.Option(False, "--no-postprocess", help="Skip post-processing (type checking, etc.)"),
-    core_package: Optional[str] = typer.Option(
+    core_package: str | None = typer.Option(
         None,
         "--core-package",
         help=(

pyopenapi_gen/context/import_collector.py

@@ -9,7 +9,7 @@ direct, relative, and plain imports, with methods to add and query import statem
 import logging
 import sys
 from collections import defaultdict
-from typing import Dict, List, Optional, Set
+from typing import List, Set
 
 # Initialize module logger
 logger = logging.getLogger(__name__)
@@ -143,18 +143,18 @@ class ImportCollector:
     def __init__(self) -> None:
         """Initialize a new ImportCollector with empty collections for all import types."""
         # Standard imports (from x import y)
-        self.imports: Dict[str, Set[str]] = {}
+        self.imports: dict[str, Set[str]] = {}
         # Direct imports like 'from datetime import date'
-        # self.direct_imports: Dict[str, Set[str]] = {} # Removed
+        # self.direct_imports: dict[str, Set[str]] = {} # Removed
         # Relative imports like 'from .models import Pet'
         self.relative_imports: defaultdict[str, set[str]] = defaultdict(set)
         # Plain imports like 'import json'
         self.plain_imports: set[str] = set()
 
         # Path information for the current file, used by get_formatted_imports
-        self._current_file_module_dot_path: Optional[str] = None
-        self._current_file_package_root: Optional[str] = None
-        self._current_file_core_pkg_name_for_abs: Optional[str] = None
+        self._current_file_module_dot_path: str | None = None
+        self._current_file_package_root: str | None = None
+        self._current_file_core_pkg_name_for_abs: str | None = None
 
     def reset(self) -> None:
         """Reset the collector to its initial empty state."""
@@ -167,9 +167,9 @@ class ImportCollector:
 
     def set_current_file_context_for_rendering(
         self,
-        current_module_dot_path: Optional[str],
-        package_root: Optional[str],
-        core_package_name_for_absolute_treatment: Optional[str],
+        current_module_dot_path: str | None,
+        package_root: str | None,
+        core_package_name_for_absolute_treatment: str | None,
     ) -> None:
         """Set the context for the current file, used by get_formatted_imports."""
         self._current_file_module_dot_path = current_module_dot_path
@@ -234,7 +234,7 @@ class ImportCollector:
         """
         self.plain_imports.add(module)
 
-    def has_import(self, module: str, name: Optional[str] = None) -> bool:
+    def has_import(self, module: str, name: str | None = None) -> bool:
         """Check if a specific module or name within a module is already imported."""
         if name:
             # Check absolute/standard imports

pyopenapi_gen/context/render_context.py

@@ -12,7 +12,7 @@ import os
 import re
 import sys
 from pathlib import Path
-from typing import Dict, Optional, Set
+from typing import Set
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -50,13 +50,13 @@ class RenderContext:
 
     def __init__(
         self,
-        file_manager: Optional[FileManager] = None,
+        file_manager: FileManager | None = None,
         core_package_name: str = "core",
-        package_root_for_generated_code: Optional[str] = None,
-        overall_project_root: Optional[str] = None,
-        parsed_schemas: Optional[Dict[str, IRSchema]] = None,
+        package_root_for_generated_code: str | None = None,
+        overall_project_root: str | None = None,
+        parsed_schemas: dict[str, IRSchema] | None = None,
         use_absolute_imports: bool = True,
-        output_package_name: Optional[str] = None,
+        output_package_name: str | None = None,
     ) -> None:
         """
         Initialize a new RenderContext.
@@ -77,15 +77,15 @@ class RenderContext:
         self.file_manager = file_manager or FileManager()
         self.import_collector = ImportCollector()
         self.generated_modules: Set[str] = set()
-        self.current_file: Optional[str] = None
+        self.current_file: str | None = None
         self.core_package_name: str = core_package_name
-        self.package_root_for_generated_code: Optional[str] = package_root_for_generated_code
-        self.overall_project_root: Optional[str] = overall_project_root or os.getcwd()
-        self.parsed_schemas: Optional[Dict[str, IRSchema]] = parsed_schemas
+        self.package_root_for_generated_code: str | None = package_root_for_generated_code
+        self.overall_project_root: str | None = overall_project_root or os.getcwd()
+        self.parsed_schemas: dict[str, IRSchema] | None = parsed_schemas
         self.use_absolute_imports: bool = use_absolute_imports
-        self.output_package_name: Optional[str] = output_package_name
+        self.output_package_name: str | None = output_package_name
         # Dictionary to store conditional imports, keyed by condition
-        self.conditional_imports: Dict[str, Dict[str, Set[str]]] = {}
+        self.conditional_imports: dict[str, dict[str, Set[str]]] = {}
 
     def set_current_file(self, abs_path: str) -> None:
         """
@@ -111,7 +111,7 @@ class RenderContext:
             core_package_name_for_absolute_treatment=self.core_package_name,
         )
 
-    def add_import(self, logical_module: str, name: Optional[str] = None, is_typing_import: bool = False) -> None:
+    def add_import(self, logical_module: str, name: str | None = None, is_typing_import: bool = False) -> None:
         """
         Add an import to the collector.
 

pyopenapi_gen/core/auth/plugins.py

@@ -1,4 +1,4 @@
-from typing import Any, Awaitable, Callable, Dict, Optional
+from typing import Any, Awaitable, Callable
 
 from .base import BaseAuth
 
@@ -9,7 +9,7 @@ class BearerAuth(BaseAuth):
     def __init__(self, token: str) -> None:
         self.token = token
 
-    async def authenticate_request(self, request_args: Dict[str, Any]) -> Dict[str, Any]:
+    async def authenticate_request(self, request_args: dict[str, Any]) -> dict[str, Any]:
         # Ensure headers dict exists
         headers = dict(request_args.get("headers", {}))
         headers["Authorization"] = f"Bearer {self.token}"
@@ -20,10 +20,10 @@ class BearerAuth(BaseAuth):
 class HeadersAuth(BaseAuth):
     """Authentication plugin for arbitrary headers."""
 
-    def __init__(self, headers: Dict[str, str]) -> None:
+    def __init__(self, headers: dict[str, str]) -> None:
         self.headers = headers
 
-    async def authenticate_request(self, request_args: Dict[str, Any]) -> Dict[str, Any]:
+    async def authenticate_request(self, request_args: dict[str, Any]) -> dict[str, Any]:
         # Merge custom headers
         hdrs = dict(request_args.get("headers", {}))
         hdrs.update(self.headers)
@@ -45,7 +45,7 @@ class ApiKeyAuth(BaseAuth):
         self.location = location
         self.name = name
 
-    async def authenticate_request(self, request_args: Dict[str, Any]) -> Dict[str, Any]:
+    async def authenticate_request(self, request_args: dict[str, Any]) -> dict[str, Any]:
         if self.location == "header":
             headers = dict(request_args.get("headers", {}))
             headers[self.name] = self.key
@@ -66,7 +66,7 @@ class ApiKeyAuth(BaseAuth):
 class OAuth2Auth(BaseAuth):
     """Authentication plugin for OAuth2 Bearer tokens, with optional auto-refresh."""
 
-    def __init__(self, access_token: str, refresh_callback: Optional[Callable[[str], Awaitable[str]]] = None) -> None:
+    def __init__(self, access_token: str, refresh_callback: Callable[[str], Awaitable[str]] | None = None) -> None:
         """
         Args:
             access_token: The OAuth2 access token.
@@ -76,7 +76,7 @@ class OAuth2Auth(BaseAuth):
         self.access_token = access_token
         self.refresh_callback = refresh_callback
 
-    async def authenticate_request(self, request_args: Dict[str, Any]) -> Dict[str, Any]:
+    async def authenticate_request(self, request_args: dict[str, Any]) -> dict[str, Any]:
         # In a real implementation, check expiry and refresh if needed
         if self.refresh_callback is not None:
             # Optionally refresh token (user must implement expiry logic)

pyopenapi_gen/core/http_status_codes.py

@@ -8,10 +8,8 @@ References:
     - IANA HTTP Status Code Registry: https://www.iana.org/assignments/http-status-codes/
 """
 
-from typing import Dict
-
 # Standard HTTP status codes with human-readable names
-HTTP_STATUS_CODES: Dict[int, str] = {
+HTTP_STATUS_CODES: dict[int, str] = {
     # 1xx Informational
     100: "Continue",
     101: "Switching Protocols",
@@ -144,7 +142,7 @@ def is_success_code(code: int) -> bool:
 
 # Mapping of HTTP status codes to Python exception class names
 # These are semantically meaningful names that Python developers expect
-HTTP_EXCEPTION_NAMES: Dict[int, str] = {
+HTTP_EXCEPTION_NAMES: dict[int, str] = {
     # 4xx Client Errors
     400: "BadRequestError",
     401: "UnauthorisedError",

pyopenapi_gen/core/http_transport.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, Optional, Protocol
+from typing import Any, Protocol
 
 import httpx
 
@@ -83,47 +83,47 @@ class HttpxTransport:
 
     Attributes:
         _client (httpx.AsyncClient): Configured HTTPX async client for all requests.
-        _auth (Optional[BaseAuth]): Optional authentication plugin for request signing (can be CompositeAuth).
-        _bearer_token (Optional[str]): Optional bearer token for Authorization header.
-        _default_headers (Optional[Dict[str, str]]): Default headers to apply to all requests.
+        _auth (BaseAuth | None): Optional authentication plugin for request signing (can be CompositeAuth).
+        _bearer_token (str | None): Optional bearer token for Authorization header.
+        _default_headers (dict[str, str] | None): Default headers to apply to all requests.
     """
 
     def __init__(
         self,
         base_url: str,
-        timeout: Optional[float] = None,
-        auth: Optional[BaseAuth] = None,
-        bearer_token: Optional[str] = None,
-        default_headers: Optional[Dict[str, str]] = None,
+        timeout: float | None = None,
+        auth: BaseAuth | None = None,
+        bearer_token: str | None = None,
+        default_headers: dict[str, str] | None = None,
     ) -> None:
         """
         Initializes the HttpxTransport.
 
         Args:
             base_url (str): The base URL for all API requests made through this transport.
-            timeout (Optional[float]): The default timeout in seconds for requests. If None, httpx's default is used.
-            auth (Optional[BaseAuth]): Optional authentication plugin for request signing (can be CompositeAuth).
-            bearer_token (Optional[str]): Optional raw bearer token string for Authorization header.
-            default_headers (Optional[Dict[str, str]]): Default headers to apply to all requests.
+            timeout (float | None): The default timeout in seconds for requests. If None, httpx's default is used.
+            auth (BaseAuth | None): Optional authentication plugin for request signing (can be CompositeAuth).
+            bearer_token (str | None): Optional raw bearer token string for Authorization header.
+            default_headers (dict[str, str] | None): Default headers to apply to all requests.
 
         Note:
             If both auth and bearer_token are provided, auth takes precedence.
         """
         self._client: httpx.AsyncClient = httpx.AsyncClient(base_url=base_url, timeout=timeout)
-        self._auth: Optional[BaseAuth] = auth
-        self._bearer_token: Optional[str] = bearer_token
-        self._default_headers: Optional[Dict[str, str]] = default_headers
+        self._auth: BaseAuth | None = auth
+        self._bearer_token: str | None = bearer_token
+        self._default_headers: dict[str, str] | None = default_headers
 
     async def _prepare_headers(
         self,
-        current_request_kwargs: Dict[str, Any],
-    ) -> Dict[str, str]:
+        current_request_kwargs: dict[str, Any],
+    ) -> dict[str, str]:
         """
         Prepares headers for an HTTP request, incorporating default headers,
         request-specific headers, and authentication.
         """
         # Initialize headers for the current request
-        prepared_headers: Dict[str, str] = {}
+        prepared_headers: dict[str, str] = {}
 
         # 1. Apply transport-level default headers
         if self._default_headers:
@@ -180,7 +180,7 @@ class HttpxTransport:
             HTTPError: For non-2xx HTTP responses.
         """
         # Prepare request arguments, excluding headers initially
-        request_args: Dict[str, Any] = {k: v for k, v in kwargs.items() if k != "headers"}
+        request_args: dict[str, Any] = {k: v for k, v in kwargs.items() if k != "headers"}
 
         # This method handles default headers, request-specific headers, and authentication
         prepared_headers = await self._prepare_headers(kwargs)

pyopenapi_gen/core/loader/operations/parser.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import logging
 import warnings
-from typing import Any, List, Mapping, Optional, cast
+from typing import Any, List, Mapping, cast
 
 from pyopenapi_gen import HTTPMethod, IROperation, IRParameter, IRRequestBody, IRResponse
 from pyopenapi_gen.core.loader.operations.post_processor import post_process_operation
@@ -96,7 +96,7 @@ def parse_operations(
                     params.append(parse_parameter(resolved_p_param_node, context, operation_id_for_promo=operation_id))
 
                 # Parse request body
-                rb: Optional[IRRequestBody] = None
+                rb: IRRequestBody | None = None
                 if "requestBody" in node_op:
                     rb = parse_request_body(
                         cast(Mapping[str, Any], node_op["requestBody"]),

pyopenapi_gen/core/loader/operations/request_body.py

@@ -6,7 +6,7 @@ Provides functions to parse and transform OpenAPI request bodies into IR format.
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, Mapping, Optional
+from typing import Any, Mapping
 
 from pyopenapi_gen import IRRequestBody, IRSchema
 from pyopenapi_gen.core.parsing.context import ParsingContext
@@ -20,7 +20,7 @@ def parse_request_body(
     raw_request_bodies: Mapping[str, Any],
     context: ParsingContext,
     operation_id: str,
-) -> Optional[IRRequestBody]:
+) -> IRRequestBody | None:
     """Parse a request body node into an IRRequestBody.
 
     Contracts:
@@ -55,7 +55,7 @@ def parse_request_body(
 
     required_flag = bool(resolved_rb_node.get("required", False))
     desc = resolved_rb_node.get("description")
-    content_map: Dict[str, IRSchema] = {}
+    content_map: dict[str, IRSchema] = {}
 
     parent_promo_name_for_req_body = f"{operation_id}RequestBody"
 

pyopenapi_gen/core/loader/parameters/parser.py

@@ -6,7 +6,7 @@ Provides functions to parse and transform OpenAPI parameters into IR format.
 from __future__ import annotations
 
 import logging
-from typing import Any, Mapping, Optional, cast
+from typing import Any, Mapping, cast
 
 from pyopenapi_gen import IRParameter, IRSchema
 from pyopenapi_gen.core.parsing.context import ParsingContext
@@ -51,7 +51,7 @@ def resolve_parameter_node_if_ref(param_node_data: Mapping[str, Any], context: P
 def parse_parameter(
     node: Mapping[str, Any],
     context: ParsingContext,
-    operation_id_for_promo: Optional[str] = None,
+    operation_id_for_promo: str | None = None,
 ) -> IRParameter:
     """Convert an OpenAPI parameter node into IRParameter.
 
@@ -74,7 +74,7 @@ def parse_parameter(
     sch = node.get("schema")
     param_name = node["name"]
 
-    name_for_inline_param_schema: Optional[str] = None
+    name_for_inline_param_schema: str | None = None
     if (
         sch
         and isinstance(sch, Mapping)

pyopenapi_gen/core/loader/responses/parser.py

@@ -6,7 +6,7 @@ Provides functions to parse and transform OpenAPI responses into IR format.
 from __future__ import annotations
 
 import logging
-from typing import Any, Dict, Mapping
+from typing import Any, Mapping
 
 from pyopenapi_gen import IRResponse, IRSchema
 from pyopenapi_gen.core.parsing.context import ParsingContext
@@ -43,7 +43,7 @@ def parse_response(
     if not operation_id_for_promo:
         raise ValueError("operation_id_for_promo must be provided")
 
-    content: Dict[str, IRSchema] = {}
+    content: dict[str, IRSchema] = {}
     STREAM_FORMATS = {
         "application/octet-stream": "octet-stream",
         "text/event-stream": "event-stream",

pyopenapi_gen/core/loader/schemas/extractor.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 
 import copy
 import logging
-from typing import Any, Dict, Mapping
+from typing import Any, Mapping
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.parsing.context import ParsingContext
@@ -17,7 +17,7 @@ from pyopenapi_gen.core.utils import NameSanitizer
 logger = logging.getLogger(__name__)
 
 
-def build_schemas(raw_schemas: Dict[str, Mapping[str, Any]], raw_components: Mapping[str, Any]) -> ParsingContext:
+def build_schemas(raw_schemas: dict[str, Mapping[str, Any]], raw_components: Mapping[str, Any]) -> ParsingContext:
     """Build all named schemas up front, populating a ParsingContext.
 
     Contracts:
@@ -47,7 +47,7 @@ def build_schemas(raw_schemas: Dict[str, Mapping[str, Any]], raw_components: Map
     return context
 
 
-def extract_inline_array_items(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
+def extract_inline_array_items(schemas: dict[str, IRSchema]) -> dict[str, IRSchema]:
     """Extract inline array item schemas as unique named schemas and update references.
 
     Contracts:
@@ -132,7 +132,7 @@ def extract_inline_array_items(schemas: Dict[str, IRSchema]) -> Dict[str, IRSche
     return schemas
 
 
-def extract_inline_enums(schemas: Dict[str, IRSchema]) -> Dict[str, IRSchema]:
+def extract_inline_enums(schemas: dict[str, IRSchema]) -> dict[str, IRSchema]:
     """Extract inline property enums as unique schemas and update property references.
 
     Also ensures top-level enum schemas are properly marked for generation.

pyopenapi_gen/core/pagination.py

@@ -6,11 +6,11 @@ turning them into convenient async iterators that automatically handle
 fetching subsequent pages.
 """
 
-from typing import Any, AsyncIterator, Awaitable, Callable, Dict
+from typing import Any, AsyncIterator, Awaitable, Callable
 
 
 def paginate_by_next(
-    fetch_page: Callable[..., Awaitable[Dict[str, Any]]],
+    fetch_page: Callable[..., Awaitable[dict[str, Any]]],
     items_key: str = "items",
     next_key: str = "next",
     **params: Any,
@@ -52,7 +52,7 @@ def paginate_by_next(
         while True:
             result = await fetch_page(**params)
             # result is expected to be a dict
-            # (assumed since fetch_page is typed to return Dict[str, Any])
+            # (assumed since fetch_page is typed to return dict[str, Any])
             items = result.get(items_key, [])
             for item in items:
                 yield item

pyopenapi_gen/core/parsing/common/ref_resolution/helpers/list_response.py

@@ -3,7 +3,7 @@ Module for handling ListResponse fallback strategy.
 """
 
 import logging
-from typing import Any, Callable, Mapping, Optional
+from typing import Any, Callable, Mapping
 
 from pyopenapi_gen.ir import IRSchema
 
@@ -17,8 +17,8 @@ def try_list_response_fallback(
     ref_value: str,
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema],
-) -> Optional[IRSchema]:
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
+) -> IRSchema | None:
     """
     Attempts to resolve a reference by treating it as a list of a base type.
 

pyopenapi_gen/core/parsing/common/ref_resolution/helpers/missing_ref.py

@@ -3,7 +3,7 @@ Module for handling missing schema references.
 """
 
 import logging
-from typing import Any, Callable, Mapping, Optional
+from typing import Any, Callable, Mapping
 
 from pyopenapi_gen.ir import IRSchema
 
@@ -19,7 +19,7 @@ def handle_missing_ref(
     ref_name: str,
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema],
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
 ) -> IRSchema:
     """
     Handles a missing schema reference by attempting fallback strategies.

pyopenapi_gen/core/parsing/common/ref_resolution/helpers/new_schema.py

@@ -3,7 +3,7 @@ Module for handling new schema references.
 """
 
 import logging
-from typing import Any, Callable, Dict, Mapping, Optional
+from typing import Any, Callable, Mapping
 
 from pyopenapi_gen.ir import IRSchema
 
@@ -15,10 +15,10 @@ logger = logging.getLogger(__name__)
 
 def parse_new_schema(
     ref_name: str,
-    node_data: Dict[str, Any],
+    node_data: dict[str, Any],
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema],
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
 ) -> IRSchema:
     """
     Parses a new schema from raw data.

pyopenapi_gen/core/parsing/common/ref_resolution/helpers/stripped_suffix.py

@@ -3,7 +3,7 @@ Module for handling stripped suffix fallback strategy.
 """
 
 import logging
-from typing import Any, Callable, Mapping, Optional
+from typing import Any, Callable, Mapping
 
 from pyopenapi_gen.ir import IRSchema
 
@@ -17,8 +17,8 @@ def try_stripped_suffix_fallback(
     ref_value: str,
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema],
-) -> Optional[IRSchema]:
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
+) -> IRSchema | None:
     """
     Attempts to resolve a reference by stripping common suffixes.
 

pyopenapi_gen/core/parsing/common/ref_resolution/resolve_schema_ref.py

@@ -3,7 +3,7 @@ Main module for schema reference resolution.
 """
 
 import logging
-from typing import Any, Callable, Mapping, Optional
+from typing import Any, Callable, Mapping
 
 from pyopenapi_gen.ir import IRSchema
 
@@ -21,7 +21,7 @@ def resolve_schema_ref(
     ref_name: str,
     context: ParsingContext,
     max_depth: int,
-    _parse_schema: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema],
+    _parse_schema: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
 ) -> IRSchema:
     """
     Resolves a schema reference in an OpenAPI specification.

pyopenapi_gen/core/parsing/common/type_parser.py

@@ -7,7 +7,6 @@ from __future__ import annotations
 from typing import (
     Any,
     List,
-    Optional,
     Tuple,
 )
 
@@ -15,8 +14,8 @@ from typing import (
 
 
 def extract_primary_type_and_nullability(
-    type_node: Any, schema_name: Optional[str] = None
-) -> Tuple[Optional[str], bool, List[str]]:
+    type_node: Any, schema_name: str | None = None
+) -> Tuple[str | None, bool, List[str]]:
     """Extract the primary type and nullability from a schema's 'type' field.
 
     Contracts:

pyopenapi_gen/core/parsing/context.py

@@ -7,7 +7,7 @@ from __future__ import annotations
 import logging
 import os
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, Any, Dict, List, Mapping, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Any, List, Mapping, Set, Tuple
 
 if TYPE_CHECKING:
     from pyopenapi_gen import IRSchema
@@ -21,12 +21,12 @@ logger = logging.getLogger(__name__)
 class ParsingContext:
     """Manages shared state and context during the schema parsing process."""
 
-    raw_spec_schemas: Dict[str, Mapping[str, Any]] = field(default_factory=dict)
+    raw_spec_schemas: dict[str, Mapping[str, Any]] = field(default_factory=dict)
     raw_spec_components: Mapping[str, Any] = field(default_factory=dict)
-    parsed_schemas: Dict[str, IRSchema] = field(default_factory=dict)
+    parsed_schemas: dict[str, IRSchema] = field(default_factory=dict)
     visited_refs: Set[str] = field(default_factory=set)
     global_schema_names: Set[str] = field(default_factory=set)
-    package_root_name: Optional[str] = None
+    package_root_name: str | None = None
     # name_sanitizer: NameSanitizer = field(default_factory=NameSanitizer) # Decided to instantiate where needed for now
     collected_warnings: List[str] = field(default_factory=list)  # For collecting warnings from helpers
 
@@ -51,7 +51,7 @@ class ParsingContext:
             max_depth=max_depth,  # Share the same parsed_schemas dict
         )
 
-    def unified_enter_schema(self, schema_name: Optional[str]) -> Any:
+    def unified_enter_schema(self, schema_name: str | None) -> Any:
         """Enter schema using unified cycle detection system."""
         from .unified_cycle_detection import unified_enter_schema
 
@@ -64,7 +64,7 @@ class ParsingContext:
 
         return result
 
-    def unified_exit_schema(self, schema_name: Optional[str]) -> None:
+    def unified_exit_schema(self, schema_name: str | None) -> None:
         """Exit schema using unified cycle detection system."""
         from .unified_cycle_detection import unified_exit_schema
 
@@ -89,7 +89,7 @@ class ParsingContext:
         self.unified_cycle_context.depth_exceeded_schemas.clear()
         self.unified_cycle_context.cycle_detected = False
 
-    def enter_schema(self, schema_name: Optional[str]) -> Tuple[bool, Optional[str]]:
+    def enter_schema(self, schema_name: str | None) -> Tuple[bool, str | None]:
         self.recursion_depth += 1
 
         if schema_name is None:
@@ -113,7 +113,7 @@ class ParsingContext:
         self.currently_parsing.append(schema_name)
         return False, None
 
-    def exit_schema(self, schema_name: Optional[str]) -> None:
+    def exit_schema(self, schema_name: str | None) -> None:
         if self.recursion_depth == 0:
             self.logger.error("Cannot exit schema: recursion depth would go below zero.")
             return
@@ -149,7 +149,7 @@ class ParsingContext:
         """Helper to get a string representation of the current parsing path for logs."""
         return " -> ".join(self.currently_parsing)
 
-    def get_parsed_schemas_for_emitter(self) -> Dict[str, IRSchema]:
+    def get_parsed_schemas_for_emitter(self) -> dict[str, IRSchema]:
         # ---- START RESTORE ----
         return {
             name: schema
@@ -173,7 +173,7 @@ class ParsingContext:
             raise TypeError("schema_name must be a string")
         return schema_name in self.parsed_schemas
 
-    def get_parsed_schema(self, schema_name: str) -> Optional["IRSchema"]:
+    def get_parsed_schema(self, schema_name: str) -> "IRSchema" | None:
         """Get a parsed schema by its name.
 
         Contracts: