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

pyopenapi_gen/core/parsing/cycle_helpers.py

@@ -1,5 +1,8 @@
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -77,7 +80,7 @@ def _handle_cycle_detection(
     return schema
 
 
-def _handle_max_depth_exceeded(original_name: Optional[str], context: ParsingContext, max_depth: int) -> IRSchema:
+def _handle_max_depth_exceeded(original_name: str | None, context: ParsingContext, max_depth: int) -> IRSchema:
     """Handle case where maximum recursion depth is exceeded.
 
     Contracts:

pyopenapi_gen/core/parsing/keywords/all_of_parser.py

@@ -6,7 +6,7 @@ Renamed from all_of_merger to all_of_parser for consistency.
 from __future__ import annotations
 
 import os
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Set, Tuple
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping, Set, Tuple
 
 from pyopenapi_gen import IRSchema
 
@@ -20,11 +20,11 @@ if TYPE_CHECKING:
 
 def _process_all_of(
     node: Mapping[str, Any],
-    current_schema_name: Optional[str],
+    current_schema_name: str | None,
     context: ParsingContext,
-    _parse_schema_func: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, Optional[int]], IRSchema],
+    _parse_schema_func: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int | None], IRSchema],
     max_depth: int = ENV_MAX_DEPTH,
-) -> Tuple[Dict[str, IRSchema], Set[str], List[IRSchema]]:
+) -> Tuple[dict[str, IRSchema], Set[str], List[IRSchema]]:
     """Processes the 'allOf' keyword in a schema node.
 
     Merges properties and required fields from all sub-schemas listed in 'allOf'
@@ -54,7 +54,7 @@ def _process_all_of(
 
     parsed_all_of_components: List[IRSchema] = []
     merged_required: Set[str] = set(node.get("required", []))
-    merged_properties: Dict[str, IRSchema] = {}
+    merged_properties: dict[str, IRSchema] = {}
 
     if "allOf" not in node:
         current_node_direct_properties = node.get("properties", {})

pyopenapi_gen/core/parsing/keywords/any_of_parser.py

@@ -4,7 +4,7 @@ Parser for 'anyOf' keyword in OpenAPI schemas.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, List, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping
 
 from pyopenapi_gen import IRSchema  # Main IR model
 
@@ -21,9 +21,9 @@ def _parse_any_of_schemas(
     context: ParsingContext,
     max_depth: int,
     parse_fn: Callable[  # Accepts the main schema parsing function
-        [Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema
+        [str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema
     ],
-) -> tuple[Optional[List[IRSchema]], bool, Optional[str]]:
+) -> tuple[List[IRSchema] | None, bool, str | None]:
     """Parses 'anyOf' sub-schemas using a provided parsing function.
 
     Contracts:
@@ -51,7 +51,7 @@ def _parse_any_of_schemas(
 
     parsed_schemas_list: List[IRSchema] = []  # Renamed to avoid confusion with module name
     is_nullable_from_any_of = False
-    effective_schema_type: Optional[str] = None
+    effective_schema_type: str | None = None
 
     for sub_node in any_of_nodes:
         if isinstance(sub_node, dict) and sub_node.get("type") == "null":

pyopenapi_gen/core/parsing/keywords/array_items_parser.py

@@ -5,7 +5,7 @@ Renamed from array_parser.py for clarity.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Callable, Mapping
 
 from pyopenapi_gen import IRSchema
 
@@ -18,14 +18,14 @@ if TYPE_CHECKING:
 
 
 def _parse_array_items_schema(
-    parent_schema_name: Optional[str],
+    parent_schema_name: str | None,
     items_node_data: Mapping[str, Any],
     context: ParsingContext,
     parse_fn: Callable[  # Accepts the main schema parsing function
-        [Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema
+        [str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema
     ],
     max_depth: int,
-) -> Optional[IRSchema]:
+) -> IRSchema | None:
     """Parses the 'items' sub-schema of an array.
 
     Args:

pyopenapi_gen/core/parsing/keywords/one_of_parser.py

@@ -4,7 +4,7 @@ Parser for 'oneOf' keyword in OpenAPI schemas.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, List, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping
 
 from pyopenapi_gen import IRSchema
 
@@ -19,8 +19,8 @@ def _parse_one_of_schemas(
     one_of_nodes: List[Mapping[str, Any]],
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, int], IRSchema],
-) -> tuple[Optional[List[IRSchema]], bool, Optional[str]]:
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int], IRSchema],
+) -> tuple[List[IRSchema] | None, bool, str | None]:
     """Parses 'oneOf' sub-schemas using a provided parsing function.
 
     Contracts:
@@ -48,7 +48,7 @@ def _parse_one_of_schemas(
 
     parsed_schemas_list: List[IRSchema] = []
     is_nullable_from_one_of = False
-    effective_schema_type: Optional[str] = None
+    effective_schema_type: str | None = None
 
     for sub_node in one_of_nodes:
         if isinstance(sub_node, dict) and sub_node.get("type") == "null":

pyopenapi_gen/core/parsing/keywords/properties_parser.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Callable, Dict, Mapping, Optional
+from typing import TYPE_CHECKING, Any, Callable, Mapping
 
 # Import NameSanitizer for use in name generation
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -27,12 +27,12 @@ if TYPE_CHECKING:
 
 def _parse_properties(
     properties_node: Mapping[str, Any],
-    parent_schema_name: Optional[str],
+    parent_schema_name: str | None,
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, Optional[int]], IRSchema],
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int | None], IRSchema],
     logger: logging.Logger,
-) -> Dict[str, IRSchema]:
+) -> dict[str, IRSchema]:
     """Parse properties from a schema node.
 
     Contracts:
@@ -45,7 +45,7 @@ def _parse_properties(
             - Returns a dictionary mapping property names to IRSchema instances
             - Property references are properly maintained
     """
-    properties_map: Dict[str, IRSchema] = {}
+    properties_map: dict[str, IRSchema] = {}
 
     for prop_key, prop_schema_node in properties_node.items():
         # Skip invalid property names

pyopenapi_gen/core/parsing/schema_finalizer.py

@@ -4,7 +4,7 @@ Finalization an IRSchema object during OpenAPI parsing.
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Callable, Dict, List, Mapping, Optional, Set, Union
+from typing import TYPE_CHECKING, Any, Callable, List, Mapping, Set, Union
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -21,24 +21,24 @@ if TYPE_CHECKING:
 
 
 def _finalize_schema_object(
-    name: Optional[str],
+    name: str | None,
     node: Mapping[str, Any],
     context: ParsingContext,
-    schema_type: Optional[str],
+    schema_type: str | None,
     is_nullable: bool,
-    any_of_schemas: Optional[List[IRSchema]],
-    one_of_schemas: Optional[List[IRSchema]],
-    parsed_all_of_components: Optional[List[IRSchema]],
-    final_properties_map: Dict[str, IRSchema],
+    any_of_schemas: List[IRSchema] | None,
+    one_of_schemas: List[IRSchema] | None,
+    parsed_all_of_components: List[IRSchema] | None,
+    final_properties_map: dict[str, IRSchema],
     merged_required_set: Set[str],
-    final_items_schema: Optional[IRSchema],
-    additional_properties_node: Optional[Union[bool, Mapping[str, Any]]],
-    enum_node: Optional[List[Any]],
-    format_node: Optional[str],
-    description_node: Optional[str],
+    final_items_schema: IRSchema | None,
+    additional_properties_node: Union[bool, Mapping[str, Any]] | None,
+    enum_node: List[Any] | None,
+    format_node: str | None,
+    description_node: str | None,
     from_unresolved_ref_node: bool,
     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],
     logger: Any,  # Changed to Any to support both real and mock loggers
 ) -> IRSchema:
     """Constructs the IRSchema object, performs final adjustments, and updates context.
@@ -71,10 +71,10 @@ def _finalize_schema_object(
             # Early return of cycle placeholder
             return existing_schema
 
-    final_enum_values: Optional[List[Any]] = enum_node if isinstance(enum_node, list) else None
+    final_enum_values: List[Any] | None = enum_node if isinstance(enum_node, list) else None
     final_required_fields_list: List[str] = sorted(list(merged_required_set))
 
-    final_additional_properties: Optional[Union[bool, IRSchema]] = None
+    final_additional_properties: Union[bool, IRSchema] | None = None
     if isinstance(additional_properties_node, bool):
         final_additional_properties = additional_properties_node
     elif isinstance(additional_properties_node, dict):

pyopenapi_gen/core/parsing/schema_parser.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import Any, Callable, Dict, List, Mapping, Optional, Set, Tuple
+from typing import Any, Callable, List, Mapping, Set, Tuple
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -32,9 +32,9 @@ except ValueError:
 
 def _resolve_ref(
     ref_path_str: str,
-    parent_schema_name: Optional[str],  # Name of the schema containing this $ref
+    parent_schema_name: str | None,  # Name of the schema containing this $ref
     context: ParsingContext,
-    max_depth_override: Optional[int],  # Propagated from the main _parse_schema call
+    max_depth_override: int | None,  # Propagated from the main _parse_schema call
     allow_self_reference_for_parent: bool,
 ) -> IRSchema:
     """Resolves a $ref string, handling cycles and depth for the referenced schema."""
@@ -82,13 +82,11 @@ def _resolve_ref(
 
 def _parse_composition_keywords(
     node: Mapping[str, Any],
-    name: Optional[str],
+    name: str | None,
     context: ParsingContext,
     max_depth: int,
-    parse_fn: Callable[[Optional[str], Optional[Mapping[str, Any]], ParsingContext, Optional[int]], IRSchema],
-) -> Tuple[
-    Optional[List[IRSchema]], Optional[List[IRSchema]], Optional[List[IRSchema]], Dict[str, IRSchema], Set[str], bool
-]:
+    parse_fn: Callable[[str | None, Mapping[str, Any] | None, ParsingContext, int | None], IRSchema],
+) -> Tuple[List[IRSchema] | None, List[IRSchema] | None, List[IRSchema] | None, dict[str, IRSchema], Set[str], bool]:
     """Parse composition keywords (anyOf, oneOf, allOf) from a schema node.
 
     Contracts:
@@ -101,10 +99,10 @@ def _parse_composition_keywords(
             - Returns a tuple of (any_of_schemas, one_of_schemas, all_of_components,
               properties, required_fields, is_nullable)
     """
-    any_of_schemas: Optional[List[IRSchema]] = None
-    one_of_schemas: Optional[List[IRSchema]] = None
-    parsed_all_of_components: Optional[List[IRSchema]] = None
-    merged_properties: Dict[str, IRSchema] = {}
+    any_of_schemas: List[IRSchema] | None = None
+    one_of_schemas: List[IRSchema] | None = None
+    parsed_all_of_components: List[IRSchema] | None = None
+    merged_properties: dict[str, IRSchema] = {}
     merged_required_set: Set[str] = set()
     is_nullable: bool = False
 
@@ -130,14 +128,14 @@ def _parse_composition_keywords(
 
 def _parse_properties(
     properties_node: Mapping[str, Any],
-    parent_schema_name: Optional[str],
-    existing_properties: Dict[str, IRSchema],  # Properties already merged, e.g., from allOf
+    parent_schema_name: str | None,
+    existing_properties: dict[str, IRSchema],  # Properties already merged, e.g., from allOf
     context: ParsingContext,
-    max_depth_override: Optional[int],
+    max_depth_override: int | None,
     allow_self_reference: bool,
-) -> Dict[str, IRSchema]:
+) -> dict[str, IRSchema]:
     """Parses the 'properties' block of a schema node."""
-    parsed_props: Dict[str, IRSchema] = existing_properties.copy()
+    parsed_props: dict[str, IRSchema] = existing_properties.copy()
 
     for prop_name, prop_schema_node in properties_node.items():
         if not isinstance(prop_name, str) or not prop_name:
@@ -316,10 +314,10 @@ def _parse_properties(
 
 
 def _parse_schema(
-    schema_name: Optional[str],
-    schema_node: Optional[Mapping[str, Any]],
+    schema_name: str | None,
+    schema_node: Mapping[str, Any] | None,
     context: ParsingContext,
-    max_depth_override: Optional[int] = None,
+    max_depth_override: int | None = None,
     allow_self_reference: bool = False,
 ) -> IRSchema:
     """
@@ -376,6 +374,8 @@ def _parse_schema(
 
     try:  # Ensure exit_schema is called
         if schema_node is None:
+            # Create empty schema for null schema nodes
+            # Do NOT set generation_name - null schemas should resolve to Any inline, not generate separate files
             return IRSchema(name=NameSanitizer.sanitize_class_name(schema_name) if schema_name else None)
 
         if not isinstance(schema_node, Mapping):
@@ -412,7 +412,7 @@ def _parse_schema(
 
             return resolved_schema
 
-        extracted_type: Optional[str] = None
+        extracted_type: str | None = None
         is_nullable_from_type_field = False
         raw_type_field = schema_node.get("type")
 
@@ -455,8 +455,10 @@ def _parse_schema(
             )
         )
 
-        is_nullable_overall = is_nullable_from_type_field or nullable_from_comp
-        final_properties_for_ir: Dict[str, IRSchema] = {}
+        # Check for direct nullable field (OpenAPI 3.0 Swagger extension)
+        is_nullable_from_node = schema_node.get("nullable", False)
+        is_nullable_overall = is_nullable_from_type_field or nullable_from_comp or is_nullable_from_node
+        final_properties_for_ir: dict[str, IRSchema] = {}
         current_final_type = extracted_type
         if not current_final_type:
             if props_from_comp or "allOf" in schema_node or "properties" in schema_node:
@@ -512,7 +514,7 @@ def _parse_schema(
         if "required" in schema_node and isinstance(schema_node["required"], list):
             final_required_fields_set.update(schema_node["required"])
 
-        items_ir: Optional[IRSchema] = None
+        items_ir: IRSchema | None = None
         if current_final_type == "array":
             items_node = schema_node.get("items")
             if items_node:
@@ -560,6 +562,22 @@ def _parse_schema(
 
         schema_ir_name_attr = NameSanitizer.sanitize_class_name(schema_name) if schema_name else None
 
+        # Parse additionalProperties field
+        additional_properties_value: bool | IRSchema | None = None
+        if "additionalProperties" in schema_node:
+            additional_props_node = schema_node["additionalProperties"]
+            if isinstance(additional_props_node, bool):
+                additional_properties_value = additional_props_node
+            elif isinstance(additional_props_node, dict):
+                # Parse the additionalProperties schema
+                additional_properties_value = _parse_schema(
+                    None,  # No name for additional properties schema
+                    additional_props_node,
+                    context,
+                    max_depth_override,
+                    allow_self_reference,
+                )
+
         schema_ir = IRSchema(
             name=schema_ir_name_attr,
             type=current_final_type,
@@ -575,11 +593,12 @@ def _parse_schema(
             example=schema_node.get("example"),
             is_nullable=is_nullable_overall,
             items=items_ir,
+            additional_properties=additional_properties_value,
         )
 
         if schema_ir.type == "array" and isinstance(schema_node.get("items"), Mapping):
             raw_items_node = schema_node["items"]
-            item_schema_context_name_for_reparse: Optional[str]
+            item_schema_context_name_for_reparse: str | None
             base_name_for_reparse_item = schema_name or "AnonymousArray"
             item_schema_context_name_for_reparse = NameSanitizer.sanitize_class_name(
                 f"{base_name_for_reparse_item}Item"

pyopenapi_gen/core/parsing/transformers/inline_enum_extractor.py

@@ -5,7 +5,7 @@ Handles the extraction of inline enums from schema definitions.
 from __future__ import annotations
 
 import logging
-from typing import Any, Mapping, Optional
+from typing import Any, Mapping
 
 from .... import IRSchema
 from ...utils import NameSanitizer
@@ -13,12 +13,12 @@ from ..context import ParsingContext
 
 
 def _extract_enum_from_property_node(
-    parent_schema_name: Optional[str],
+    parent_schema_name: str | None,
     property_key: str,
     property_node_data: Mapping[str, Any],
     context: ParsingContext,
     logger: logging.Logger,
-) -> Optional[IRSchema]:
+) -> IRSchema | None:
     """
     Checks a property's schema node for an inline enum definition.
 
@@ -126,7 +126,7 @@ def _extract_enum_from_property_node(
 
 
 def _process_standalone_inline_enum(
-    schema_name: Optional[str],  # The original intended name for this schema
+    schema_name: str | None,  # The original intended name for this schema
     node_data: Mapping[str, Any],  # The raw node data for this schema
     schema_obj: IRSchema,  # The IRSchema object already partially parsed for this node
     context: ParsingContext,

pyopenapi_gen/core/parsing/transformers/inline_object_promoter.py

@@ -5,7 +5,10 @@ Handles the promotion of inline object schemas to global schemas.
 from __future__ import annotations
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
 
 from .... import IRSchema
 from ...utils import NameSanitizer
@@ -13,12 +16,12 @@ from ..context import ParsingContext
 
 
 def _attempt_promote_inline_object(
-    parent_schema_name: Optional[str],  # Name of the schema containing the property
+    parent_schema_name: str | None,  # Name of the schema containing the property
     property_key: str,  # The key (name) of the property being processed
     property_schema_obj: IRSchema,  # The IRSchema of the property itself (already parsed)
     context: ParsingContext,
     logger: logging.Logger,
-) -> Optional[IRSchema]:
+) -> IRSchema | None:
     logger.debug(
         f"PROMO_ATTEMPT: parent='{parent_schema_name}', prop_key='{property_key}', "
         f"prop_schema_name='{property_schema_obj.name}', prop_schema_type='{property_schema_obj.type}', "
@@ -75,7 +78,7 @@ def _attempt_promote_inline_object(
     else:
         base_name_candidate = sanitized_prop_key_class_name
 
-    chosen_global_name: Optional[str] = None
+    chosen_global_name: str | None = None
 
     # Check if the primary candidate name is available or already points to this object
     if base_name_candidate in context.parsed_schemas:

pyopenapi_gen/core/parsing/unified_cycle_detection.py

@@ -10,7 +10,7 @@ from __future__ import annotations
 import logging
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Dict, List, Optional, Set
+from typing import List, Set
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -62,10 +62,10 @@ class CycleDetectionResult:
     """Result of cycle detection check."""
 
     is_cycle: bool
-    cycle_type: Optional[CycleType]
+    cycle_type: CycleType | None
     action: CycleAction
-    cycle_info: Optional[CycleInfo] = None
-    placeholder_schema: Optional[IRSchema] = None
+    cycle_info: CycleInfo | None = None
+    placeholder_schema: IRSchema | None = None
 
 
 @dataclass
@@ -74,8 +74,8 @@ class UnifiedCycleContext:
 
     # Core tracking
     schema_stack: List[str] = field(default_factory=list)
-    schema_states: Dict[str, SchemaState] = field(default_factory=dict)
-    parsed_schemas: Dict[str, IRSchema] = field(default_factory=dict)
+    schema_states: dict[str, SchemaState] = field(default_factory=dict)
+    parsed_schemas: dict[str, IRSchema] = field(default_factory=dict)
     recursion_depth: int = 0
 
     # Detection results
@@ -155,7 +155,7 @@ def create_depth_placeholder(schema_name: str, depth: int) -> IRSchema:
     )
 
 
-def unified_cycle_check(schema_name: Optional[str], context: UnifiedCycleContext) -> CycleDetectionResult:
+def unified_cycle_check(schema_name: str | None, context: UnifiedCycleContext) -> CycleDetectionResult:
     """Unified cycle detection that handles all cases."""
 
     if schema_name is None:
@@ -262,7 +262,7 @@ def unified_cycle_check(schema_name: Optional[str], context: UnifiedCycleContext
     return CycleDetectionResult(False, None, CycleAction.CONTINUE_PARSING)
 
 
-def unified_enter_schema(schema_name: Optional[str], context: UnifiedCycleContext) -> CycleDetectionResult:
+def unified_enter_schema(schema_name: str | None, context: UnifiedCycleContext) -> CycleDetectionResult:
     """Unified entry point that always maintains consistent state."""
     context.recursion_depth += 1
 
@@ -275,7 +275,7 @@ def unified_enter_schema(schema_name: Optional[str], context: UnifiedCycleContex
     return result
 
 
-def unified_exit_schema(schema_name: Optional[str], context: UnifiedCycleContext) -> None:
+def unified_exit_schema(schema_name: str | None, context: UnifiedCycleContext) -> None:
     """Unified exit that always maintains consistent state."""
     if context.recursion_depth > 0:
         context.recursion_depth -= 1
@@ -288,6 +288,6 @@ def unified_exit_schema(schema_name: Optional[str], context: UnifiedCycleContext
         context.schema_states[schema_name] = SchemaState.COMPLETED
 
 
-def get_schema_or_placeholder(schema_name: str, context: UnifiedCycleContext) -> Optional[IRSchema]:
+def get_schema_or_placeholder(schema_name: str, context: UnifiedCycleContext) -> IRSchema | None:
     """Get an existing schema or placeholder from the context."""
     return context.parsed_schemas.get(schema_name)

pyopenapi_gen/core/schemas.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import MISSING, dataclass, fields
-from typing import Any, Dict, Type, TypeVar, Union, get_args, get_origin, get_type_hints
+from typing import Any, Type, TypeVar, Union, get_args, get_origin, get_type_hints
 
 T = TypeVar("T", bound="BaseSchema")
 
@@ -10,7 +10,7 @@ def _extract_base_type(field_type: Any) -> Any:
     """Extract the base type from Optional/Union types."""
     origin = get_origin(field_type)
     if origin is Union:
-        # For Optional[T] or Union[T, None], get the non-None type
+        # For T | None or Union[T, None], get the non-None type
         args = get_args(field_type)
         non_none_args = [arg for arg in args if arg is not type(None)]
         if len(non_none_args) == 1:
@@ -23,26 +23,26 @@ class BaseSchema:
     """Base class for all generated models, providing validation, dict conversion, and field mapping."""
 
     @classmethod
-    def _get_field_mappings(cls) -> Dict[str, str]:
+    def _get_field_mappings(cls) -> dict[str, str]:
         """Get field mappings from Meta class if defined. Returns API field -> Python field mappings."""
         if hasattr(cls, "Meta") and hasattr(cls.Meta, "key_transform_with_load"):
             return cls.Meta.key_transform_with_load  # type: ignore[no-any-return]
         return {}
 
     @classmethod
-    def _get_reverse_field_mappings(cls) -> Dict[str, str]:
+    def _get_reverse_field_mappings(cls) -> dict[str, str]:
         """Get reverse field mappings. Returns Python field -> API field mappings."""
         mappings = cls._get_field_mappings()
         return {python_field: api_field for api_field, python_field in mappings.items()}
 
     @classmethod
-    def from_dict(cls: Type[T], data: Dict[str, Any]) -> T:
+    def from_dict(cls: Type[T], data: dict[str, Any]) -> T:
         """Create an instance from a dictionary with automatic field name mapping."""
         if not isinstance(data, dict):
             raise TypeError(f"Input must be a dictionary, got {type(data).__name__}")
 
         field_mappings = cls._get_field_mappings()  # API -> Python
-        kwargs: Dict[str, Any] = {}
+        kwargs: dict[str, Any] = {}
         cls_fields = {f.name: f for f in fields(cls)}
 
         # Process each field in the data
@@ -64,7 +64,7 @@ class BaseSchema:
                     # Fall back to raw annotation if get_type_hints fails
                     pass
 
-                # Extract base type (handles Optional[Type] -> Type)
+                # Extract base type (handles Type | None -> Type)
                 base_type = _extract_base_type(field_type)
 
                 if base_type is not None and hasattr(base_type, "from_dict") and isinstance(value, dict):
@@ -90,7 +90,7 @@ class BaseSchema:
 
         return cls(**kwargs)
 
-    def to_dict(self, exclude_none: bool = False) -> Dict[str, Any]:
+    def to_dict(self, exclude_none: bool = False) -> dict[str, Any]:
         """Convert the model instance to a dictionary with reverse field name mapping."""
         reverse_mappings = self._get_reverse_field_mappings()  # Python -> API
         result = {}
@@ -116,10 +116,10 @@ class BaseSchema:
 
     # Legacy aliases for backward compatibility
     @classmethod
-    def model_validate(cls: Type[T], data: Dict[str, Any]) -> T:
+    def model_validate(cls: Type[T], data: dict[str, Any]) -> T:
         """Legacy alias for from_dict."""
         return cls.from_dict(data)
 
-    def model_dump(self, exclude_none: bool = False) -> Dict[str, Any]:
+    def model_dump(self, exclude_none: bool = False) -> dict[str, Any]:
         """Legacy alias for to_dict."""
         return self.to_dict(exclude_none=exclude_none)

pyopenapi_gen/core/streaming_helpers.py

@@ -1,17 +1,15 @@
 import json
-from typing import Any, AsyncIterator, List, Optional
+from typing import Any, AsyncIterator, List
 
 import httpx
 
 
 class SSEEvent:
-    def __init__(
-        self, data: str, event: Optional[str] = None, id: Optional[str] = None, retry: Optional[int] = None
-    ) -> None:
+    def __init__(self, data: str, event: str | None = None, id: str | None = None, retry: int | None = None) -> None:
         self.data: str = data
-        self.event: Optional[str] = event
-        self.id: Optional[str] = id
-        self.retry: Optional[int] = retry
+        self.event: str | None = event
+        self.id: str | None = id
+        self.retry: int | None = retry
 
     def __repr__(self) -> str:
         return f"SSEEvent(data={self.data!r}, event={self.event!r}, id={self.id!r}, retry={self.retry!r})"