pyopenapi-gen 0.13.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

@@ -0,0 +1,218 @@
+"""HTTP status code definitions and human-readable names.
+
+This module provides a registry of standard HTTP status codes with their
+canonical names according to RFC specifications.
+
+References:
+    - RFC 9110 (HTTP Semantics): https://www.rfc-editor.org/rfc/rfc9110.html
+    - IANA HTTP Status Code Registry: https://www.iana.org/assignments/http-status-codes/
+"""
+
+# Standard HTTP status codes with human-readable names
+HTTP_STATUS_CODES: dict[int, str] = {
+    # 1xx Informational
+    100: "Continue",
+    101: "Switching Protocols",
+    102: "Processing",
+    103: "Early Hints",
+    # 2xx Success
+    200: "OK",
+    201: "Created",
+    202: "Accepted",
+    203: "Non-Authoritative Information",
+    204: "No Content",
+    205: "Reset Content",
+    206: "Partial Content",
+    207: "Multi-Status",
+    208: "Already Reported",
+    226: "IM Used",
+    # 3xx Redirection
+    300: "Multiple Choices",
+    301: "Moved Permanently",
+    302: "Found",
+    303: "See Other",
+    304: "Not Modified",
+    305: "Use Proxy",
+    307: "Temporary Redirect",
+    308: "Permanent Redirect",
+    # 4xx Client Error
+    400: "Bad Request",
+    401: "Unauthorised",
+    402: "Payment Required",
+    403: "Forbidden",
+    404: "Not Found",
+    405: "Method Not Allowed",
+    406: "Not Acceptable",
+    407: "Proxy Authentication Required",
+    408: "Request Timeout",
+    409: "Conflict",
+    410: "Gone",
+    411: "Length Required",
+    412: "Precondition Failed",
+    413: "Payload Too Large",
+    414: "URI Too Long",
+    415: "Unsupported Media Type",
+    416: "Range Not Satisfiable",
+    417: "Expectation Failed",
+    418: "I'm a teapot",
+    421: "Misdirected Request",
+    422: "Unprocessable Entity",
+    423: "Locked",
+    424: "Failed Dependency",
+    425: "Too Early",
+    426: "Upgrade Required",
+    428: "Precondition Required",
+    429: "Too Many Requests",
+    431: "Request Header Fields Too Large",
+    451: "Unavailable For Legal Reasons",
+    # 5xx Server Error
+    500: "Internal Server Error",
+    501: "Not Implemented",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    504: "Gateway Timeout",
+    505: "HTTP Version Not Supported",
+    506: "Variant Also Negotiates",
+    507: "Insufficient Storage",
+    508: "Loop Detected",
+    510: "Not Extended",
+    511: "Network Authentication Required",
+}
+
+
+def get_status_name(code: int) -> str:
+    """Get the human-readable name for an HTTP status code.
+
+    Args:
+        code: HTTP status code (e.g., 404)
+
+    Returns:
+        Human-readable status name (e.g., "Not Found"), or "Unknown" if not found
+    """
+    return HTTP_STATUS_CODES.get(code, "Unknown")
+
+
+def is_error_code(code: int) -> bool:
+    """Check if a status code represents an error (4xx or 5xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a client or server error, False otherwise
+    """
+    return 400 <= code < 600
+
+
+def is_client_error(code: int) -> bool:
+    """Check if a status code represents a client error (4xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a client error, False otherwise
+    """
+    return 400 <= code < 500
+
+
+def is_server_error(code: int) -> bool:
+    """Check if a status code represents a server error (5xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a server error, False otherwise
+    """
+    return 500 <= code < 600
+
+
+def is_success_code(code: int) -> bool:
+    """Check if a status code represents success (2xx).
+
+    Args:
+        code: HTTP status code
+
+    Returns:
+        True if the code is a success code, False otherwise
+    """
+    return 200 <= code < 300
+
+
+# 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] = {
+    # 4xx Client Errors
+    400: "BadRequestError",
+    401: "UnauthorisedError",
+    402: "PaymentRequiredError",
+    403: "ForbiddenError",
+    404: "NotFoundError",
+    405: "MethodNotAllowedError",
+    406: "NotAcceptableError",
+    407: "ProxyAuthenticationRequiredError",
+    408: "RequestTimeoutError",
+    409: "ConflictError",
+    410: "GoneError",
+    411: "LengthRequiredError",
+    412: "PreconditionFailedError",
+    413: "PayloadTooLargeError",
+    414: "UriTooLongError",
+    415: "UnsupportedMediaTypeError",
+    416: "RangeNotSatisfiableError",
+    417: "ExpectationFailedError",
+    418: "ImATeapotError",
+    421: "MisdirectedRequestError",
+    422: "UnprocessableEntityError",
+    423: "LockedError",
+    424: "FailedDependencyError",
+    425: "TooEarlyError",
+    426: "UpgradeRequiredError",
+    428: "PreconditionRequiredError",
+    429: "TooManyRequestsError",
+    431: "RequestHeaderFieldsTooLargeError",
+    451: "UnavailableForLegalReasonsError",
+    # 5xx Server Errors
+    500: "InternalServerError",
+    501: "NotImplementedError",  # Note: Conflicts with Python built-in, will be handled
+    502: "BadGatewayError",
+    503: "ServiceUnavailableError",
+    504: "GatewayTimeoutError",
+    505: "HttpVersionNotSupportedError",
+    506: "VariantAlsoNegotiatesError",
+    507: "InsufficientStorageError",
+    508: "LoopDetectedError",
+    510: "NotExtendedError",
+    511: "NetworkAuthenticationRequiredError",
+}
+
+
+def get_exception_class_name(code: int) -> str:
+    """Get the Python exception class name for an HTTP status code.
+
+    Args:
+        code: HTTP status code (e.g., 404)
+
+    Returns:
+        Python exception class name (e.g., "NotFoundError"), or "Error{code}" as fallback
+
+    Examples:
+        >>> get_exception_class_name(404)
+        'NotFoundError'
+        >>> get_exception_class_name(429)
+        'TooManyRequestsError'
+        >>> get_exception_class_name(999)  # Unknown code
+        'Error999'
+    """
+    # Check if we have a semantic name for this code
+    if code in HTTP_EXCEPTION_NAMES:
+        name = HTTP_EXCEPTION_NAMES[code]
+        # Handle Python keyword conflicts
+        if name == "NotImplementedError":
+            # Avoid conflict with Python's built-in NotImplementedError
+            return "HttpNotImplementedError"
+        return name
+
+    # Fallback to Error{code} for codes we don't have semantic names for
+    return f"Error{code}"

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.