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

pyopenapi_gen/visit/endpoint/generators/response_handler_generator.py

@@ -5,7 +5,7 @@ Helper class for generating response handling logic for an endpoint method.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Optional, TypedDict
+from typing import TYPE_CHECKING, Any, TypedDict
 
 from pyopenapi_gen.core.http_status_codes import get_exception_class_name
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
@@ -44,8 +44,8 @@ class DefaultCase(TypedDict):
 class EndpointResponseHandlerGenerator:
     """Generates the response handling logic for an endpoint method."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def _is_type_alias_to_array(self, type_name: str) -> bool:
         """
@@ -130,7 +130,7 @@ class EndpointResponseHandlerGenerator:
         Determine if a type should use BaseSchema deserialization.
 
         Args:
-            type_name: The Python type name (e.g., "User", "List[User]", "Optional[User]")
+            type_name: The Python type name (e.g., "User", "List[User]", "User | None")
 
         Returns:
             True if the type should use BaseSchema .from_dict() deserialization
@@ -138,14 +138,14 @@ class EndpointResponseHandlerGenerator:
         # Extract the base type name from complex types
         base_type = type_name
 
-        # Handle List[Type], Optional[Type], etc.
+        # Handle List[Type], Type | None, etc.
         if "[" in base_type and "]" in base_type:
-            # Extract the inner type from List[Type], Optional[Type], etc.
+            # Extract the inner type from List[Type], Type | None, etc.
             start_bracket = base_type.find("[")
             end_bracket = base_type.rfind("]")
             inner_type = base_type[start_bracket + 1 : end_bracket]
 
-            # For Union types like Optional[User] -> Union[User, None], take the first type
+            # For Union types like User | None -> Union[User, None], take the first type
             if ", " in inner_type:
                 inner_type = inner_type.split(", ")[0]
 
@@ -168,8 +168,9 @@ class EndpointResponseHandlerGenerator:
         }:
             return False
 
-        # Skip typing constructs (both uppercase and lowercase)
-        if base_type.startswith(("Dict[", "List[", "Optional[", "Union[", "Tuple[", "dict[", "list[", "tuple[")):
+        # Skip typing constructs
+        # Note: Modern Python 3.10+ uses | None instead of Optional[X]
+        if base_type.startswith(("dict[", "List[", "Union[", "Tuple[", "dict[", "list[", "tuple[")):
             return False
 
         # Check if this is a type alias (array or non-array) - these should NOT use BaseSchema
@@ -180,8 +181,7 @@ class EndpointResponseHandlerGenerator:
         # Check if it's a model type (contains a dot indicating it's from models package)
         # or if it's a simple class name that's likely a generated model (starts with uppercase)
         return "." in base_type or (
-            base_type[0].isupper()
-            and base_type not in {"Dict", "List", "Optional", "Union", "Tuple", "dict", "list", "tuple"}
+            base_type[0].isupper() and base_type not in {"Dict", "List", "Union", "Tuple", "dict", "list", "tuple"}
         )
 
     def _get_base_schema_deserialization_code(self, return_type: str, data_expr: str) -> str:
@@ -203,8 +203,29 @@ class EndpointResponseHandlerGenerator:
                 item_type = return_type[5:-1]  # Remove 'list[' and ']'
             return f"[{item_type}.from_dict(item) for item in {data_expr}]"
         elif return_type.startswith("Optional["):
-            # Handle Optional[Model] types
+            # SANITY CHECK: Unified type system should never produce Optional[X]
+            logger.error(
+                f"❌ ARCHITECTURE VIOLATION: Received legacy Optional[X] type in response handler: {return_type}. "
+                f"Unified type system must generate X | None directly."
+            )
+            # Defensive conversion (but this indicates a serious bug upstream)
             inner_type = return_type[9:-1]  # Remove 'Optional[' and ']'
+            logger.warning(f"⚠️ Converting to modern syntax internally for: {inner_type} | None")
+
+            # Check if inner type is also a list
+            if inner_type.startswith("List[") or inner_type.startswith("list["):
+                list_code = self._get_base_schema_deserialization_code(inner_type, data_expr)
+                return f"{list_code} if {data_expr} is not None else None"
+            else:
+                return f"{inner_type}.from_dict({data_expr}) if {data_expr} is not None else None"
+        elif " | None" in return_type or return_type.endswith("| None"):
+            # Handle Model | None types (modern Python 3.10+ syntax)
+            # Extract base type from "X | None" pattern
+            if " | None" in return_type:
+                inner_type = return_type.replace(" | None", "").strip()
+            else:
+                inner_type = return_type.replace("| None", "").strip()
+
             # Check if inner type is also a list
             if inner_type.startswith("List[") or inner_type.startswith("list["):
                 list_code = self._get_base_schema_deserialization_code(inner_type, data_expr)
@@ -230,7 +251,7 @@ class EndpointResponseHandlerGenerator:
         return_type: str,
         context: RenderContext,
         op: IROperation,
-        response_ir: Optional[IRResponse] = None,
+        response_ir: IRResponse | None = None,
     ) -> str:
         """Determines the code snippet to extract/transform the response body."""
         # Handle None, StreamingResponse, Iterator, etc.
@@ -243,7 +264,7 @@ class EndpointResponseHandlerGenerator:
             if return_type == "AsyncIterator[bytes]":
                 context.add_import(f"{context.core_package_name}.streaming_helpers", "iter_bytes")
                 return "iter_bytes(response)"
-            elif "Dict[str, Any]" in return_type or "dict" in return_type.lower():
+            elif "dict[str, Any]" in return_type or "dict" in return_type.lower():
                 # For event streams that return Dict objects
                 context.add_import(f"{context.core_package_name}.streaming_helpers", "iter_sse_events_text")
                 return "sse_json_stream_marker"  # Special marker handled by _write_parsed_return
@@ -260,7 +281,7 @@ class EndpointResponseHandlerGenerator:
                 return "iter_bytes(response)"
 
         # Special case for "data: Any" unwrapping when the actual schema has no fields/properties
-        if return_type in {"Dict[str, Any]", "Dict[str, object]", "object", "Any"}:
+        if return_type in {"dict[str, Any]", "dict[str, object]", "object", "Any"}:
             context.add_import("typing", "Dict")
             context.add_import("typing", "Any")
 
@@ -273,7 +294,7 @@ class EndpointResponseHandlerGenerator:
             return "response.json()  # Type is Any"
         elif return_type == "None":
             return "None"  # This will be handled by generate_response_handling directly
-        else:  # Includes schema-defined models, List[], Dict[], Optional[]
+        else:  # Includes schema-defined models, List[], dict[], Optional[]
             context.add_typing_imports_for_type(return_type)  # Ensure model itself is imported
 
             # Check if we should use BaseSchema deserialization instead of cast()
@@ -434,7 +455,7 @@ class EndpointResponseHandlerGenerator:
             context.add_import("typing", "cast")
             writer.write_line(f"return cast({strategy.return_type}, response.json())")
 
-    def _get_response_schema(self, response_ir: IRResponse) -> Optional[IRSchema]:
+    def _get_response_schema(self, response_ir: IRResponse) -> IRSchema | None:
         """Extract the schema from a response IR."""
         if not response_ir.content:
             return None

pyopenapi_gen/visit/endpoint/generators/signature_generator.py

@@ -5,7 +5,7 @@ Helper class for generating the method signature for an endpoint.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, List
 
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
@@ -24,15 +24,15 @@ logger = logging.getLogger(__name__)
 class EndpointMethodSignatureGenerator:
     """Generates the Python method signature for an endpoint operation."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def generate_signature(
         self,
         writer: CodeWriter,
         op: IROperation,
         context: RenderContext,
-        ordered_params: List[Dict[str, Any]],
+        ordered_params: List[dict[str, Any]],
         strategy: ResponseStrategy,
     ) -> None:
         """Writes the method signature to the provided CodeWriter."""

pyopenapi_gen/visit/endpoint/generators/url_args_generator.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import logging
 import re  # For _build_url_with_path_vars
-from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from typing import TYPE_CHECKING, Any, List
 
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
@@ -21,8 +21,8 @@ logger = logging.getLogger(__name__)
 class EndpointUrlArgsGenerator:
     """Generates URL, query, and header parameters for an endpoint method."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def _build_url_with_path_vars(self, path: str) -> str:
         """Builds the f-string for URL construction, substituting path variables."""
@@ -34,7 +34,7 @@ class EndpointUrlArgsGenerator:
         return f'f"{{self.base_url}}{formatted_path}"'
 
     def _write_query_params(
-        self, writer: CodeWriter, op: IROperation, ordered_params: List[Dict[str, Any]], context: RenderContext
+        self, writer: CodeWriter, op: IROperation, ordered_params: List[dict[str, Any]], context: RenderContext
     ) -> None:
         """Writes query parameter dictionary construction."""
         # Logic from EndpointMethodGenerator._write_query_params
@@ -58,7 +58,7 @@ class EndpointUrlArgsGenerator:
                 )
 
     def _write_header_params(
-        self, writer: CodeWriter, op: IROperation, ordered_params: List[Dict[str, Any]], context: RenderContext
+        self, writer: CodeWriter, op: IROperation, ordered_params: List[dict[str, Any]], context: RenderContext
     ) -> None:
         """Writes header parameter dictionary construction."""
         # Logic from EndpointMethodGenerator._write_header_params
@@ -89,9 +89,9 @@ class EndpointUrlArgsGenerator:
         writer: CodeWriter,
         op: IROperation,
         context: RenderContext,
-        ordered_params: List[Dict[str, Any]],
-        primary_content_type: Optional[str],
-        resolved_body_type: Optional[str],
+        ordered_params: List[dict[str, Any]],
+        primary_content_type: str | None,
+        resolved_body_type: str | None,
     ) -> bool:
         """Writes URL, query, and header parameters. Returns True if header params were written."""
         # Main logic from EndpointMethodGenerator._write_url_and_args
@@ -103,9 +103,9 @@ class EndpointUrlArgsGenerator:
         # Check if any parameter in ordered_params is a query param, not just op.parameters
         has_spec_query_params = any(p.get("param_in") == "query" for p in ordered_params)
         if has_spec_query_params:
-            context.add_import("typing", "Any")  # For Dict[str, Any]
-            context.add_import("typing", "Dict")  # For Dict[str, Any]
-            writer.write_line("params: Dict[str, Any] = {")
+            context.add_import("typing", "Any")  # For dict[str, Any]
+            context.add_import("typing", "Dict")  # For dict[str, Any]
+            writer.write_line("params: dict[str, Any] = {")
             # writer.indent() # Indentation should be handled by CodeWriter when writing lines
             self._write_query_params(writer, op, ordered_params, context)
             # writer.dedent()
@@ -115,9 +115,9 @@ class EndpointUrlArgsGenerator:
         # Header Parameters
         has_header_params = any(p.get("param_in") == "header" for p in ordered_params)
         if has_header_params:
-            context.add_import("typing", "Any")  # For Dict[str, Any]
-            context.add_import("typing", "Dict")  # For Dict[str, Any]
-            writer.write_line("headers: Dict[str, Any] = {")
+            context.add_import("typing", "Any")  # For dict[str, Any]
+            context.add_import("typing", "Dict")  # For dict[str, Any]
+            writer.write_line("headers: dict[str, Any] = {")
             # writer.indent()
             self._write_header_params(writer, op, ordered_params, context)
             # writer.dedent()
@@ -160,11 +160,11 @@ class EndpointUrlArgsGenerator:
                     context.add_import("typing", "IO")  # For IO[Any]
                     context.add_import("typing", "Any")
                     writer.write_line(
-                        "files_data: Dict[str, IO[Any]] = DataclassSerializer.serialize(files)  # type failed"
+                        "files_data: dict[str, IO[Any]] = DataclassSerializer.serialize(files)  # type failed"
                     )
             elif primary_content_type == "application/x-www-form-urlencoded":
                 # form_data is the expected parameter name from EndpointParameterProcessor
-                # resolved_body_type should be Dict[str, Any]
+                # resolved_body_type should be dict[str, Any]
                 if resolved_body_type:
                     writer.write_line(
                         f"form_data_body: {resolved_body_type} = DataclassSerializer.serialize(form_data)"
@@ -173,7 +173,7 @@ class EndpointUrlArgsGenerator:
                     context.add_import("typing", "Dict")
                     context.add_import("typing", "Any")
                     writer.write_line(
-                        "form_data_body: Dict[str, Any] = DataclassSerializer.serialize(form_data)  # Fallback type"
+                        "form_data_body: dict[str, Any] = DataclassSerializer.serialize(form_data)  # Fallback type"
                     )
             elif resolved_body_type == "bytes":  # e.g. application/octet-stream
                 # bytes_content is the expected parameter name from EndpointParameterProcessor

pyopenapi_gen/visit/endpoint/processors/import_analyzer.py

@@ -5,7 +5,7 @@ Helper class for analyzing an IROperation and registering necessary imports.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Optional  # IO for multipart type hint
+from typing import TYPE_CHECKING, Any  # IO for multipart type hint
 
 # Necessary helpers for type analysis
 from pyopenapi_gen.helpers.endpoint_utils import (
@@ -24,8 +24,8 @@ logger = logging.getLogger(__name__)
 class EndpointImportAnalyzer:
     """Analyzes an IROperation to determine and register required imports."""
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def analyze_and_register_imports(
         self,
@@ -40,21 +40,21 @@ class EndpointImportAnalyzer:
 
         if op.request_body:
             content_types = op.request_body.content.keys()
-            body_param_type: Optional[str] = None
+            body_param_type: str | None = None
             if "multipart/form-data" in content_types:
-                # Type for multipart is Dict[str, IO[Any]] which requires IO and Any
+                # Type for multipart is dict[str, IO[Any]] which requires IO and Any
                 context.add_import("typing", "Dict")
                 context.add_import("typing", "IO")
                 context.add_import("typing", "Any")
-                # The actual type string "Dict[str, IO[Any]]" will be handled by add_typing_imports_for_type if passed
+                # The actual type string "dict[str, IO[Any]]" will be handled by add_typing_imports_for_type if passed
                 # but ensuring components are imported is key.
-                body_param_type = "Dict[str, IO[Any]]"
+                body_param_type = "dict[str, IO[Any]]"
             elif "application/json" in content_types:
                 body_param_type = get_request_body_type(op.request_body, context, self.schemas)
             elif "application/x-www-form-urlencoded" in content_types:
                 context.add_import("typing", "Dict")
                 context.add_import("typing", "Any")
-                body_param_type = "Dict[str, Any]"
+                body_param_type = "dict[str, Any]"
             elif content_types:  # Fallback for other types like application/octet-stream
                 body_param_type = "bytes"
 

pyopenapi_gen/visit/endpoint/processors/parameter_processor.py

@@ -5,7 +5,7 @@ Helper class for processing parameters for an endpoint method.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple
+from typing import TYPE_CHECKING, Any, List, Tuple
 
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.helpers.endpoint_utils import get_param_type, get_request_body_type
@@ -24,12 +24,12 @@ class EndpointParameterProcessor:
     method parameters for the endpoint signature and further processing.
     """
 
-    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
-        self.schemas: Dict[str, Any] = schemas or {}
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
 
     def process_parameters(
         self, op: IROperation, context: RenderContext
-    ) -> Tuple[List[Dict[str, Any]], Optional[str], Optional[str]]:
+    ) -> Tuple[List[dict[str, Any]], str | None, str | None]:
         """
         Prepares and orders parameters for an endpoint method, including path,
         query, header, and request body parameters.
@@ -40,8 +40,8 @@ class EndpointParameterProcessor:
             - primary_content_type: The dominant content type for the request body.
             - resolved_body_type: The Python type hint for the request body.
         """
-        ordered_params: List[Dict[str, Any]] = []
-        param_details_map: Dict[str, Dict[str, Any]] = {}
+        ordered_params: List[dict[str, Any]] = []
+        param_details_map: dict[str, dict[str, Any]] = {}
 
         for param in op.parameters:
             param_name_sanitized = NameSanitizer.sanitize_method_name(param.name)
@@ -56,21 +56,21 @@ class EndpointParameterProcessor:
             ordered_params.append(param_info)
             param_details_map[param_name_sanitized] = param_info
 
-        primary_content_type: Optional[str] = None
-        resolved_body_type: Optional[str] = None
+        primary_content_type: str | None = None
+        resolved_body_type: str | None = None
 
         if op.request_body:
             content_types = op.request_body.content.keys()
             body_param_name = "body"  # Default name
             context.add_import("typing", "Any")  # General fallback
-            body_specific_param_info: Optional[Dict[str, Any]] = None
+            body_specific_param_info: dict[str, Any] | None = None
 
             if "multipart/form-data" in content_types:
                 primary_content_type = "multipart/form-data"
                 body_param_name = "files"
                 context.add_import("typing", "Dict")
                 context.add_import("typing", "IO")
-                resolved_body_type = "Dict[str, IO[Any]]"
+                resolved_body_type = "dict[str, IO[Any]]"
                 body_specific_param_info = {
                     "name": body_param_name,
                     "type": resolved_body_type,
@@ -95,7 +95,7 @@ class EndpointParameterProcessor:
                 primary_content_type = "application/x-www-form-urlencoded"
                 body_param_name = "form_data"
                 context.add_import("typing", "Dict")
-                resolved_body_type = "Dict[str, Any]"
+                resolved_body_type = "dict[str, Any]"
                 body_specific_param_info = {
                     "name": body_param_name,
                     "type": resolved_body_type,
@@ -138,8 +138,8 @@ class EndpointParameterProcessor:
         return final_ordered_params, primary_content_type, resolved_body_type
 
     def _ensure_path_variables_as_params(
-        self, op: IROperation, current_params: List[Dict[str, Any]], param_details_map: Dict[str, Dict[str, Any]]
-    ) -> List[Dict[str, Any]]:
+        self, op: IROperation, current_params: List[dict[str, Any]], param_details_map: dict[str, dict[str, Any]]
+    ) -> List[dict[str, Any]]:
         """
         Ensures that all variables in the URL path are present in the list of parameters.
         If a path variable is not already defined as a parameter, it's added as a required string type.

pyopenapi_gen/visit/model/alias_generator.py

@@ -3,13 +3,11 @@ Generates Python code for type aliases from IRSchema objects.
 """
 
 import logging
-from typing import Dict, Optional
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
 from pyopenapi_gen.core.utils import NameSanitizer
 from pyopenapi_gen.core.writers.python_construct_renderer import PythonConstructRenderer
-from pyopenapi_gen.helpers.type_resolution.finalizer import TypeFinalizer
 from pyopenapi_gen.types.services.type_service import UnifiedTypeService
 
 logger = logging.getLogger(__name__)
@@ -21,7 +19,7 @@ class AliasGenerator:
     def __init__(
         self,
         renderer: PythonConstructRenderer,
-        all_schemas: Optional[Dict[str, IRSchema]],
+        all_schemas: dict[str, IRSchema] | None,
     ):
         # Pre-condition
         if renderer is None:
@@ -70,7 +68,6 @@ class AliasGenerator:
 
         alias_name = NameSanitizer.sanitize_class_name(base_name)
         target_type = self.type_service.resolve_schema_type(schema, context, required=True, resolve_underlying=True)
-        target_type = TypeFinalizer(context)._clean_type(target_type)
 
         # logger.debug(f"AliasGenerator: Rendering alias '{alias_name}' for target type '{target_type}'.")
 

pyopenapi_gen/visit/model/dataclass_generator.py

@@ -4,7 +4,7 @@ Generates Python code for dataclasses from IRSchema objects.
 
 import json
 import logging
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, List, Tuple
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
@@ -22,7 +22,7 @@ class DataclassGenerator:
     def __init__(
         self,
         renderer: PythonConstructRenderer,
-        all_schemas: Optional[Dict[str, IRSchema]],
+        all_schemas: dict[str, IRSchema] | None,
     ):
         """
         Initialize a new DataclassGenerator.
@@ -37,7 +37,130 @@ class DataclassGenerator:
         self.all_schemas = all_schemas if all_schemas is not None else {}
         self.type_service = UnifiedTypeService(self.all_schemas)
 
-    def _get_field_default(self, ps: IRSchema, context: RenderContext) -> Optional[str]:
+    def _is_arbitrary_json_object(self, schema: IRSchema) -> bool:
+        """
+        Check if schema represents an arbitrary JSON object (additionalProperties but no properties).
+
+        Args:
+            schema: The schema to check.
+
+        Returns:
+            True if this is an arbitrary JSON object that should use wrapper class.
+        """
+        return (
+            schema.type == "object"
+            and not schema.properties  # No defined properties
+            and (
+                schema.additional_properties is True  # Explicit true
+                or isinstance(schema.additional_properties, IRSchema)  # Schema for additional props
+            )
+        )
+
+    def _generate_json_wrapper_class(
+        self,
+        class_name: str,
+        schema: IRSchema,
+        context: RenderContext,
+    ) -> str:
+        """
+        Generate a wrapper class for arbitrary JSON objects.
+
+        This wrapper class preserves all JSON data and provides dict-like access,
+        preventing data loss when deserializing API responses with arbitrary properties.
+
+        Args:
+            class_name: Name of the wrapper class.
+            schema: The schema (should have additionalProperties but no properties).
+            context: Render context for imports.
+
+        Returns:
+            Python code for the wrapper class.
+        """
+        # Register required imports
+        context.add_import("dataclasses", "dataclass")
+        context.add_import("dataclasses", "field")
+        context.add_import("typing", "Any")
+        context.add_import("..core.schemas", "BaseSchema")
+
+        description = schema.description or "Generic JSON value object that preserves arbitrary data."
+
+        # Generate the wrapper class code
+        code = f'''__all__ = ["{class_name}"]
+
+@dataclass
+class {class_name}(BaseSchema):
+    """
+    {description}
+
+    This class wraps arbitrary JSON objects with no defined schema,
+    preserving all data during serialization/deserialization.
+    """
+
+    _data: dict[str, Any] = field(default_factory=dict, repr=False)
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> '{class_name}':
+        """
+        Create {class_name} from dictionary, preserving all data.
+
+        Args:
+            data: Dictionary with arbitrary keys and values.
+
+        Returns:
+            {class_name} instance containing the data.
+        """
+        instance = cls(_data=data)
+        return instance
+
+    def to_dict(self, exclude_none: bool = False) -> dict[str, Any]:
+        """
+        Convert back to dictionary.
+
+        Args:
+            exclude_none: If True, exclude None values from output.
+
+        Returns:
+            Dictionary representation of the data.
+        """
+        if exclude_none:
+            return {{k: v for k, v in self._data.items() if v is not None}}
+        return self._data.copy()
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """Dict-like get method for backward compatibility."""
+        return self._data.get(key, default)
+
+    def __getitem__(self, key: str) -> Any:
+        """Dict-like item access."""
+        return self._data[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        """Dict-like item setting."""
+        self._data[key] = value
+
+    def __contains__(self, key: str) -> bool:
+        """Dict-like 'in' operator."""
+        return key in self._data
+
+    def __bool__(self) -> bool:
+        """Truthy if contains data."""
+        return bool(self._data)
+
+    def keys(self) -> Any:
+        """Return dictionary keys."""
+        return self._data.keys()
+
+    def values(self) -> Any:
+        """Return dictionary values."""
+        return self._data.values()
+
+    def items(self) -> Any:
+        """Return dictionary items."""
+        return self._data.items()
+'''
+        return code
+
+    def _get_field_default(self, ps: IRSchema, context: RenderContext) -> str | None:
         """
         Determines the default value expression string for a dataclass field.
         This method is called for fields determined to be optional.
@@ -88,7 +211,7 @@ class DataclassGenerator:
         """Check if field mapping is required between API and Python field names."""
         return api_field != python_field
 
-    def _generate_field_mappings(self, properties: Dict[str, Any], sanitized_names: Dict[str, str]) -> Dict[str, str]:
+    def _generate_field_mappings(self, properties: dict[str, Any], sanitized_names: dict[str, str]) -> dict[str, str]:
         """Generate field mappings for BaseSchema configuration."""
         mappings = {}
         for api_name, python_name in sanitized_names.items():
@@ -96,7 +219,7 @@ class DataclassGenerator:
                 mappings[api_name] = python_name
         return mappings
 
-    def _has_any_mappings(self, properties: Dict[str, Any], sanitized_names: Dict[str, str]) -> bool:
+    def _has_any_mappings(self, properties: dict[str, Any], sanitized_names: dict[str, str]) -> bool:
         """Check if any field mappings are needed."""
         return bool(self._generate_field_mappings(properties, sanitized_names))
 
@@ -137,9 +260,17 @@ class DataclassGenerator:
             raise ValueError("RenderContext cannot be None.")
         # Additional check for schema type might be too strict here, as ModelVisitor decides eligibility.
 
+        # Check if this is an arbitrary JSON object that needs wrapper class
+        if self._is_arbitrary_json_object(schema):
+            logger.info(
+                f"DataclassGenerator: Schema '{base_name}' is an arbitrary JSON object. "
+                "Generating wrapper class to preserve data."
+            )
+            return self._generate_json_wrapper_class(base_name, schema, context)
+
         class_name = base_name
-        fields_data: List[Tuple[str, str, Optional[str], Optional[str]]] = []
-        field_mappings: Dict[str, str] = {}
+        fields_data: List[Tuple[str, str, str | None, str | None]] = []
+        field_mappings: dict[str, str] = {}
 
         if schema.type == "array" and schema.items:
             field_name_for_array_content = "items"
@@ -147,7 +278,6 @@ class DataclassGenerator:
                 raise ValueError("Schema items must be present for array type dataclass field.")
 
             list_item_py_type = self.type_service.resolve_schema_type(schema.items, context, required=True)
-            list_item_py_type = TypeFinalizer(context)._clean_type(list_item_py_type)
             field_type_str = f"List[{list_item_py_type}]"
 
             final_field_type_str = TypeFinalizer(context).finalize(
@@ -191,9 +321,8 @@ class DataclassGenerator:
                     field_mappings[prop_name] = field_name
 
                 py_type = self.type_service.resolve_schema_type(prop_schema, context, required=is_required)
-                py_type = TypeFinalizer(context)._clean_type(py_type)
 
-                default_expr: Optional[str] = None
+                default_expr: str | None = None
                 if not is_required:
                     default_expr = self._get_field_default(prop_schema, context)
 

pyopenapi_gen/visit/model/model_visitor.py

@@ -6,7 +6,6 @@ defined in OpenAPI specifications, supporting type aliases, enums, and dataclass
 """
 
 import logging
-from typing import Dict, Optional
 
 from pyopenapi_gen import IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
@@ -36,7 +35,7 @@ class ModelVisitor(Visitor[IRSchema, str]):
             - All necessary imports for the generated model are registered in the context.
     """
 
-    def __init__(self, schemas: Optional[Dict[str, IRSchema]] = None) -> None:
+    def __init__(self, schemas: dict[str, IRSchema] | None = None) -> None:
         """
         Initialize a new ModelVisitor.
 
@@ -156,7 +155,7 @@ class ModelVisitor(Visitor[IRSchema, str]):
 
         return self.formatter.format(rendered_code)
 
-    def _get_field_default(self, ps: IRSchema, context: RenderContext) -> Optional[str]:
+    def _get_field_default(self, ps: IRSchema, context: RenderContext) -> str | None:
         """
         Determines the default value expression string for a dataclass field.
         This method is called for fields determined to be optional.