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

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:

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: