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

pyopenapi_gen/ir.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, List, Union
 
 # Import NameSanitizer at the top for type hints and __post_init__ usage
 from pyopenapi_gen.core.utils import NameSanitizer
@@ -16,33 +16,33 @@ from .http_types import HTTPMethod
 
 @dataclass
 class IRSchema:
-    name: Optional[str] = None
-    type: Optional[str] = None  # E.g., "object", "array", "string", or a reference to another schema name
-    format: Optional[str] = None
-    description: Optional[str] = None
+    name: str | None = None
+    type: str | None = None  # E.g., "object", "array", "string", or a reference to another schema name
+    format: str | None = None
+    description: str | None = None
     required: List[str] = field(default_factory=list)
-    properties: Dict[str, IRSchema] = field(default_factory=dict)
-    items: Optional[IRSchema] = None  # For type: "array"
-    enum: Optional[List[Any]] = None
-    default: Optional[Any] = None  # Added default value
-    example: Optional[Any] = None  # Added example value
-    additional_properties: Optional[Union[bool, IRSchema]] = None  # True, False, or an IRSchema
+    properties: dict[str, IRSchema] = field(default_factory=dict)
+    items: IRSchema | None = None  # For type: "array"
+    enum: List[Any] | None = None
+    default: Any | None = None  # Added default value
+    example: Any | None = None  # Added example value
+    additional_properties: Union[bool, IRSchema] | None = None  # True, False, or an IRSchema
     is_nullable: bool = False
-    any_of: Optional[List[IRSchema]] = None
-    one_of: Optional[List[IRSchema]] = None
-    all_of: Optional[List[IRSchema]] = None  # Store the list of IRSchema objects from allOf
-    title: Optional[str] = None  # Added title
+    any_of: List[IRSchema] | None = None
+    one_of: List[IRSchema] | None = None
+    all_of: List[IRSchema] | None = None  # Store the list of IRSchema objects from allOf
+    title: str | None = None  # Added title
     is_data_wrapper: bool = False  # True if schema is a simple {{ "data": OtherSchema }} wrapper
 
     # Internal generator flags/helpers
     _from_unresolved_ref: bool = field(
         default=False, repr=False
     )  # If this IRSchema is a placeholder for an unresolvable $ref
-    _refers_to_schema: Optional[IRSchema] = (
+    _refers_to_schema: IRSchema | None = (
         None  # If this schema is a reference (e.g. a promoted property), this can link to the actual definition
     )
     _is_circular_ref: bool = field(default=False, repr=False)  # If this IRSchema is part of a circular reference chain
-    _circular_ref_path: Optional[str] = field(default=None, repr=False)  # Path of the circular reference
+    _circular_ref_path: str | None = field(default=None, repr=False)  # Path of the circular reference
     _max_depth_exceeded_marker: bool = field(
         default=False, repr=False
     )  # If parsing this schema or its components exceeded max depth
@@ -50,13 +50,11 @@ class IRSchema:
     _is_name_derived: bool = field(
         default=False, repr=False
     )  # True if the name was derived (e.g. for promoted inline objects)
-    _inline_name_resolution_path: Optional[str] = field(
-        default=None, repr=False
-    )  # Path used for resolving inline names
+    _inline_name_resolution_path: str | None = field(default=None, repr=False)  # Path used for resolving inline names
 
     # Fields for storing final, de-collided names for code generation
-    generation_name: Optional[str] = field(default=None, repr=True)  # Final class/enum name
-    final_module_stem: Optional[str] = field(default=None, repr=True)  # Final module filename stem
+    generation_name: str | None = field(default=None, repr=True)  # Final class/enum name
+    final_module_stem: str | None = field(default=None, repr=True)  # Final module filename stem
 
     def __post_init__(self) -> None:
         # Ensure name is always a valid Python identifier if set
@@ -119,25 +117,25 @@ class IRParameter:
     param_in: str  # Renamed from 'in' to avoid keyword clash, was in_: str in original __init__.py
     required: bool
     schema: IRSchema
-    description: Optional[str] = None
-    # example: Optional[Any] = None # This was in my latest ir.py but not __init__.py, keeping it from my version
+    description: str | None = None
+    # example: Any | None = None # This was in my latest ir.py but not __init__.py, keeping it from my version
 
 
 # Adding other IR classes from the original __init__.py structure
 @dataclass(slots=True)
 class IRResponse:
     status_code: str  # can be "default" or specific status like "200"
-    description: Optional[str]
-    content: Dict[str, IRSchema]  # media‑type → schema mapping
+    description: str | None
+    content: dict[str, IRSchema]  # media‑type → schema mapping
     stream: bool = False  # Indicates a binary or streaming response
-    stream_format: Optional[str] = None  # Indicates the stream type
+    stream_format: str | None = None  # Indicates the stream type
 
 
 @dataclass(slots=True)
 class IRRequestBody:
     required: bool
-    content: Dict[str, IRSchema]  # media‑type → schema mapping
-    description: Optional[str] = None
+    content: dict[str, IRSchema]  # media‑type → schema mapping
+    description: str | None = None
 
 
 @dataclass(slots=True)
@@ -145,10 +143,10 @@ class IROperation:
     operation_id: str
     method: HTTPMethod  # Enforced via enum for consistency
     path: str  # e.g. "/pets/{petId}"
-    summary: Optional[str]
-    description: Optional[str]
+    summary: str | None
+    description: str | None
     parameters: List[IRParameter] = field(default_factory=list)
-    request_body: Optional[IRRequestBody] = None
+    request_body: IRRequestBody | None = None
     responses: List[IRResponse] = field(default_factory=list)
     tags: List[str] = field(default_factory=list)
 
@@ -157,8 +155,8 @@ class IROperation:
 class IRSpec:
     title: str
     version: str
-    description: Optional[str] = None
-    schemas: Dict[str, IRSchema] = field(default_factory=dict)
+    description: str | None = None
+    schemas: dict[str, IRSchema] = field(default_factory=dict)
     operations: List[IROperation] = field(default_factory=list)
     servers: List[str] = field(default_factory=list)
 

pyopenapi_gen/types/contracts/protocols.py

@@ -1,7 +1,7 @@
 """Protocols for type resolution components."""
 
 from abc import ABC, abstractmethod
-from typing import Dict, Optional, Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 from pyopenapi_gen import IROperation, IRResponse, IRSchema
 
@@ -25,11 +25,11 @@ class ReferenceResolver(ABC):
     """Resolves OpenAPI $ref references to target schemas."""
 
     # Concrete implementations should have these attributes
-    schemas: Dict[str, IRSchema]
-    responses: Dict[str, IRResponse]
+    schemas: dict[str, IRSchema]
+    responses: dict[str, IRResponse]
 
     @abstractmethod
-    def resolve_ref(self, ref: str) -> Optional[IRSchema]:
+    def resolve_ref(self, ref: str) -> IRSchema | None:
         """
         Resolve a $ref string to the target schema.
 
@@ -42,7 +42,7 @@ class ReferenceResolver(ABC):
         pass
 
     @abstractmethod
-    def resolve_response_ref(self, ref: str) -> Optional[IRResponse]:
+    def resolve_response_ref(self, ref: str) -> IRResponse | None:
         """
         Resolve a response $ref to the target response.
 

pyopenapi_gen/types/contracts/types.py

@@ -1,7 +1,6 @@
 """Core types for type resolution."""
 
 from dataclasses import dataclass
-from typing import Optional
 
 
 class TypeResolutionError(Exception):
@@ -16,8 +15,8 @@ class ResolvedType:
 
     python_type: str
     needs_import: bool = False
-    import_module: Optional[str] = None
-    import_name: Optional[str] = None
+    import_module: str | None = None
+    import_name: str | None = None
     is_optional: bool = False
     is_forward_ref: bool = False
 

pyopenapi_gen/types/resolvers/reference_resolver.py

@@ -1,7 +1,7 @@
 """Reference resolver implementation."""
 
 import logging
-from typing import Dict, Optional
+from typing import Dict
 
 from pyopenapi_gen import IRResponse, IRSchema
 
@@ -13,7 +13,7 @@ logger = logging.getLogger(__name__)
 class OpenAPIReferenceResolver(ReferenceResolver):
     """Resolves OpenAPI $ref references."""
 
-    def __init__(self, schemas: Dict[str, IRSchema], responses: Optional[Dict[str, IRResponse]] = None):
+    def __init__(self, schemas: Dict[str, IRSchema], responses: Dict[str, IRResponse] | None = None):
         """
         Initialize reference resolver.
 
@@ -24,7 +24,7 @@ class OpenAPIReferenceResolver(ReferenceResolver):
         self.schemas = schemas
         self.responses = responses or {}
 
-    def resolve_ref(self, ref: str) -> Optional[IRSchema]:
+    def resolve_ref(self, ref: str) -> IRSchema | None:
         """
         Resolve a schema $ref to the target schema.
 
@@ -47,7 +47,7 @@ class OpenAPIReferenceResolver(ReferenceResolver):
 
         return schema
 
-    def resolve_response_ref(self, ref: str) -> Optional[IRResponse]:
+    def resolve_response_ref(self, ref: str) -> IRResponse | None:
         """
         Resolve a response $ref to the target response.
 

pyopenapi_gen/types/resolvers/response_resolver.py

@@ -1,7 +1,10 @@
 """Response type resolver implementation."""
 
 import logging
-from typing import Optional
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    pass
 
 from pyopenapi_gen import IROperation, IRResponse, IRSchema
 
@@ -84,7 +87,7 @@ class OpenAPIResponseResolver(ResponseTypeResolver):
 
         return self.resolve_specific_response(target_response, context)
 
-    def _get_primary_response(self, operation: IROperation) -> Optional[IRResponse]:
+    def _get_primary_response(self, operation: IROperation) -> IRResponse | None:
         """Get the primary success response from an operation."""
         if not operation.responses:
             return None
@@ -161,9 +164,8 @@ class OpenAPIResponseResolver(ResponseTypeResolver):
         # For event streams (text/event-stream) or JSON streams
         is_event_stream = any("event-stream" in ct for ct in content_types)
         if is_event_stream:
-            context.add_import("typing", "Dict")
             context.add_import("typing", "Any")
-            return ResolvedType(python_type="AsyncIterator[Dict[str, Any]]")
+            return ResolvedType(python_type="AsyncIterator[dict[str, Any]]")
 
         # For other streaming content, try to resolve the schema
         schema = self._get_response_schema(response)

pyopenapi_gen/types/resolvers/schema_resolver.py

@@ -44,6 +44,21 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         if hasattr(schema, "ref") and schema.ref:
             return self._resolve_reference(schema.ref, context, required, resolve_underlying)
 
+        # Handle null schemas (schemas with no type and no generation_name) - resolve to Any inline
+        # These are schemas from null schema nodes in the OpenAPI spec
+        # IMPORTANT: Don't treat schemas with names that exist in the registry as null schemas
+        schema_type = getattr(schema, "type", None)
+        if (
+            schema_type is None
+            and not (hasattr(schema, "generation_name") and schema.generation_name)
+            and not (hasattr(schema, "any_of") and schema.any_of)
+            and not (hasattr(schema, "one_of") and schema.one_of)
+            and not (hasattr(schema, "all_of") and schema.all_of)
+            and not (schema.name and schema.name in getattr(self.ref_resolver, "schemas", {}))
+        ):
+            # This is a null schema - respect the required parameter for optionality
+            return self._resolve_null(context, required)
+
         # Handle named schemas with generation_name (fully processed schemas)
         if schema.name and hasattr(schema, "generation_name") and schema.generation_name:
             # If resolve_underlying is True, skip named schema resolution for type aliases
@@ -132,7 +147,7 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
                 )
             elif schema_type == "None" or schema_type is None:
                 logger.info(
-                    "Schema type 'None' detected - likely an optional field or null type. This will be mapped to Optional[Any]."
+                    "Schema type 'None' detected - likely an optional field or null type. This will be mapped to Any | None."
                 )
                 return self._resolve_null(context, required)
             elif schema_type and isinstance(schema_type, str):
@@ -143,7 +158,7 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
                 logger.info("  3. Custom type not supported by OpenAPI (consider using allOf/oneOf/anyOf)")
                 logger.info(f"  Location: Check your OpenAPI spec for schemas with type='{schema_type}'")
 
-            return self._resolve_any(context)
+            return self._resolve_any(context, required)
 
     def _resolve_reference(
         self, ref: str, context: TypeContext, required: bool, resolve_underlying: bool = False
@@ -287,12 +302,13 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         return ResolvedType(python_type="bool", is_optional=not required)
 
     def _resolve_null(self, context: TypeContext, required: bool) -> ResolvedType:
-        """Resolve null type."""
-        # For null types in schemas, we need to import Any for the Optional[Any] pattern
-        # But the type itself is None for union composition
-        if not required:
-            context.add_import("typing", "Any")
-        return ResolvedType(python_type="None", is_optional=not required)
+        """Resolve null type.
+
+        When a schema has type=null or no type defined (None), we map it to Python's Any type
+        because null schemas represent unknown/arbitrary data rather than the None value.
+        """
+        context.add_import("typing", "Any")
+        return ResolvedType(python_type="Any", is_optional=not required)
 
     def _resolve_array(
         self, schema: IRSchema, context: TypeContext, required: bool, resolve_underlying: bool = False
@@ -337,25 +353,25 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
             # Generic object
             context.add_import("typing", "Dict")
             context.add_import("typing", "Any")
-            return ResolvedType(python_type="Dict[str, Any]", is_optional=not required)
+            return ResolvedType(python_type="dict[str, Any]", is_optional=not required)
 
         # Object with properties - should be promoted to named type
         logger.warning("Found object with properties - should be promoted to named type")
         context.add_import("typing", "Dict")
         context.add_import("typing", "Any")
-        return ResolvedType(python_type="Dict[str, Any]", is_optional=not required)
+        return ResolvedType(python_type="dict[str, Any]", is_optional=not required)
 
-    def _resolve_any(self, context: TypeContext) -> ResolvedType:
+    def _resolve_any(self, context: TypeContext, required: bool = True) -> ResolvedType:
         """Resolve to Any type."""
         context.add_import("typing", "Any")
-        return ResolvedType(python_type="Any")
+        return ResolvedType(python_type="Any", is_optional=not required)
 
     def _resolve_any_of(
         self, schema: IRSchema, context: TypeContext, required: bool, resolve_underlying: bool = False
     ) -> ResolvedType:
         """Resolve anyOf composition to Union type."""
         if not schema.any_of:
-            return self._resolve_any(context)
+            return self._resolve_any(context, required)
 
         resolved_types = []
         for sub_schema in schema.any_of:
@@ -392,7 +408,7 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         # For allOf, we typically need to merge the schemas
         # For now, we'll use the first schema if it has a clear type
         if not schema.all_of:
-            return self._resolve_any(context)
+            return self._resolve_any(context, required)
 
         # Simple implementation: use the first concrete schema
         for sub_schema in schema.all_of:
@@ -401,14 +417,14 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
 
         # Fallback - if no schema has a concrete type, return Any
         # Don't recurse into schemas with no type as that causes warnings
-        return self._resolve_any(context)
+        return self._resolve_any(context, required)
 
     def _resolve_one_of(
         self, schema: IRSchema, context: TypeContext, required: bool, resolve_underlying: bool = False
     ) -> ResolvedType:
         """Resolve oneOf composition to Union type."""
         if not schema.one_of:
-            return self._resolve_any(context)
+            return self._resolve_any(context, required)
 
         resolved_types = []
         for sub_schema in schema.one_of:

pyopenapi_gen/types/services/type_service.py

@@ -1,7 +1,6 @@
 """Unified type resolution service."""
 
 import logging
-from typing import Dict, Optional
 
 from pyopenapi_gen import IROperation, IRResponse, IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
@@ -35,7 +34,7 @@ class UnifiedTypeService:
     and operations to Python type strings.
     """
 
-    def __init__(self, schemas: Dict[str, IRSchema], responses: Optional[Dict[str, IRResponse]] = None):
+    def __init__(self, schemas: dict[str, IRSchema], responses: dict[str, IRResponse] | None = None):
         """
         Initialize the type service.
 
@@ -68,7 +67,29 @@ class UnifiedTypeService:
 
         type_context = RenderContextAdapter(context)
         resolved = self.schema_resolver.resolve_schema(schema, type_context, effective_required, resolve_underlying)
-        return self._format_resolved_type(resolved, context)
+
+        # DEBUG: Log resolved type before formatting
+        if resolved.python_type and "[" in resolved.python_type:
+            bracket_count_open = resolved.python_type.count("[")
+            bracket_count_close = resolved.python_type.count("]")
+            if bracket_count_open != bracket_count_close:
+                logger.warning(
+                    f"BRACKET MISMATCH BEFORE FORMAT: '{resolved.python_type}', "
+                    f"schema_name: {getattr(schema, 'name', 'anonymous')}, "
+                    f"schema_type: {getattr(schema, 'type', None)}, "
+                    f"is_optional: {resolved.is_optional}"
+                )
+
+        formatted = self._format_resolved_type(resolved, context)
+
+        # DEBUG: Log final formatted type
+        if formatted and "[" in formatted:
+            bracket_count_open = formatted.count("[")
+            bracket_count_close = formatted.count("]")
+            if bracket_count_open != bracket_count_close:
+                logger.warning(f"BRACKET MISMATCH AFTER FORMAT: '{formatted}', " f"original: '{resolved.python_type}'")
+
+        return formatted
 
     def resolve_operation_response_type(self, operation: IROperation, context: RenderContext) -> str:
         """
@@ -101,15 +122,40 @@ class UnifiedTypeService:
         return self._format_resolved_type(resolved, context)
 
     def _format_resolved_type(self, resolved: ResolvedType, context: RenderContext | None = None) -> str:
-        """Format a ResolvedType into a Python type string."""
-        python_type = resolved.python_type
+        """Format a ResolvedType into a Python type string.
 
-        if resolved.is_optional and not python_type.startswith("Optional["):
-            if context:
-                context.add_import("typing", "Optional")
-            python_type = f"Optional[{python_type}]"
+        Architecture Guarantee: This method produces ONLY modern Python 3.10+ syntax (X | None).
+        Optional[X] is NEVER generated - unified type system uses | None exclusively.
+        """
+        python_type = resolved.python_type
 
+        # SANITY CHECK: Unified system should never produce Optional[X] internally
+        if python_type.startswith("Optional["):
+            logger.error(
+                f"❌ ARCHITECTURE VIOLATION: Resolver produced legacy Optional[X]: {python_type}. "
+                f"Unified type system must generate X | None directly. "
+                f"This indicates a bug in schema/response/reference resolver."
+            )
+            # This should never happen in our unified system
+            raise ValueError(
+                f"Type resolver produced legacy Optional[X] syntax: {python_type}. "
+                f"Unified type system must use X | None exclusively."
+            )
+
+        # Quote forward references BEFORE adding | None so we get: "DataSource" | None not "DataSource | None"
         if resolved.is_forward_ref and not python_type.startswith('"'):
             python_type = f'"{python_type}"'
 
+        # Add modern | None syntax if needed
+        # Modern Python 3.10+ uses | None syntax without needing Optional import
+        if resolved.is_optional and not python_type.endswith("| None"):
+            python_type = f"{python_type} | None"
+
+            # DEBUG: Check for malformed type strings
+            if python_type.count("[") != python_type.count("]"):
+                logger.warning(
+                    f"MALFORMED TYPE: Bracket mismatch in '{python_type}'. "
+                    f"Original: '{resolved.python_type}', is_optional: {resolved.is_optional}"
+                )
+
         return python_type

pyopenapi_gen/types/strategies/response_strategy.py

@@ -8,7 +8,6 @@ from __future__ import annotations
 
 import logging
 from dataclasses import dataclass
-from typing import Dict, Optional
 
 from pyopenapi_gen import IROperation, IRResponse, IRSchema
 from pyopenapi_gen.context.render_context import RenderContext
@@ -28,11 +27,11 @@ class ResponseStrategy:
     """
 
     return_type: str  # The Python type for method signature
-    response_schema: Optional[IRSchema]  # The response schema as defined in OpenAPI spec
+    response_schema: IRSchema | None  # The response schema as defined in OpenAPI spec
     is_streaming: bool  # Whether this is a streaming response
 
     # Additional context for code generation
-    response_ir: Optional[IRResponse]  # The original response IR
+    response_ir: IRResponse | None  # The original response IR
 
 
 class ResponseStrategyResolver:
@@ -43,7 +42,7 @@ class ResponseStrategyResolver:
     previously spread across multiple components.
     """
 
-    def __init__(self, schemas: Dict[str, IRSchema]):
+    def __init__(self, schemas: dict[str, IRSchema]):
         self.schemas = schemas
         self.type_service = UnifiedTypeService(schemas)
 
@@ -89,7 +88,7 @@ class ResponseStrategyResolver:
             return_type=return_type, response_schema=response_schema, is_streaming=False, response_ir=primary_response
         )
 
-    def _get_primary_response(self, operation: IROperation) -> Optional[IRResponse]:
+    def _get_primary_response(self, operation: IROperation) -> IRResponse | None:
         """Get the primary success response from an operation."""
         if not operation.responses:
             return None
@@ -113,7 +112,7 @@ class ResponseStrategyResolver:
         # First response as fallback
         return operation.responses[0] if operation.responses else None
 
-    def _get_response_schema(self, response: IRResponse) -> Optional[IRSchema]:
+    def _get_response_schema(self, response: IRResponse) -> IRSchema | None:
         """Get the schema from a response's content."""
         if not response.content:
             return None
@@ -164,7 +163,7 @@ class ResponseStrategyResolver:
             context.add_import("typing", "Dict")
             context.add_import("typing", "Any")
             return ResponseStrategy(
-                return_type="AsyncIterator[Dict[str, Any]]",
+                return_type="AsyncIterator[dict[str, Any]]",
                 response_schema=None,
                 is_streaming=True,
                 response_ir=response,

pyopenapi_gen/visit/client_visitor.py

@@ -79,7 +79,7 @@ class ClientVisitor:
         # For now, the client_py_content check in the test looks for this for ApiKeyAuth specifically:
         context.add_import(f"{context.core_package_name}.auth.plugins", "ApiKeyAuth")
 
-        context.add_typing_imports_for_type("Optional[HttpTransport]")
+        context.add_typing_imports_for_type("HttpTransport | None")
         context.add_typing_imports_for_type("Any")
         context.add_typing_imports_for_type("Dict")
         # Class definition
@@ -103,7 +103,7 @@ class ClientVisitor:
         summary = "Async API client with pluggable transport, tag-specific clients, and client-level headers."
         args: list[tuple[str, str, str]] = [
             ("config", "ClientConfig", "Client configuration object."),
-            ("transport", "Optional[HttpTransport]", "Custom HTTP transport (optional)."),
+            ("transport", "HttpTransport | None", "Custom HTTP transport (optional)."),
         ]
         for tag, class_name, module_name in tag_tuples:
             args.append((module_name, class_name, f"Client for '{tag}' endpoints."))
@@ -121,9 +121,7 @@ class ClientVisitor:
         writer.indent()  # Back to class indent (1)
         writer.write_line('"""')
         # __init__
-        writer.write_line(
-            "def __init__(self, config: ClientConfig, transport: Optional[HttpTransport] = None) -> None:"
-        )
+        writer.write_line("def __init__(self, config: ClientConfig, transport: HttpTransport | None = None) -> None:")
         writer.indent()
         writer.write_line("self.config = config")
         writer.write_line(
@@ -133,8 +131,8 @@ class ClientVisitor:
         writer.write_line("self._base_url: str = str(self.config.base_url)")
         # Initialize private fields for each tag client
         for tag, class_name, module_name in tag_tuples:
-            context.add_typing_imports_for_type(f"Optional[{class_name}]")
-            writer.write_line(f"self._{module_name}: Optional[{class_name}] = None")
+            context.add_typing_imports_for_type(f"{class_name} | None")
+            writer.write_line(f"self._{module_name}: {class_name} | None = None")
         writer.dedent()
         writer.write_line("")
         # @property for each tag client

pyopenapi_gen/visit/endpoint/generators/docstring_generator.py

@@ -6,7 +6,7 @@ from __future__ import annotations
 
 import logging
 import textwrap  # For _wrap_docstring logic
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any
 
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
 from pyopenapi_gen.core.writers.documentation_writer import DocumentationBlock, DocumentationWriter
@@ -23,8 +23,8 @@ logger = logging.getLogger(__name__)
 class EndpointDocstringGenerator:
     """Generates the Python docstring 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 {}
         self.doc_writer = DocumentationWriter(width=88)
 
     def _wrap_docstring(self, prefix: str, text: str, width: int = 88) -> str:
@@ -50,7 +50,7 @@ class EndpointDocstringGenerator:
         writer: CodeWriter,
         op: IROperation,
         context: RenderContext,
-        primary_content_type: Optional[str],
+        primary_content_type: str | None,
         response_strategy: ResponseStrategy,
     ) -> None:
         """Writes the method docstring to the provided CodeWriter."""
@@ -67,10 +67,10 @@ class EndpointDocstringGenerator:
             body_desc = op.request_body.description or "Request body."
             # Standardized body parameter names based on content type
             if primary_content_type == "multipart/form-data":
-                args.append(("files", "Dict[str, IO[Any]]", body_desc + " (multipart/form-data)"))
+                args.append(("files", "dict[str, IO[Any]]", body_desc + " (multipart/form-data)"))
             elif primary_content_type == "application/x-www-form-urlencoded":
-                # The type here could be more specific if schema is available, but Dict[str, Any] is a safe default.
-                args.append(("form_data", "Dict[str, Any]", body_desc + " (x-www-form-urlencoded)"))
+                # The type here could be more specific if schema is available, but dict[str, Any] is a safe default.
+                args.append(("form_data", "dict[str, Any]", body_desc + " (x-www-form-urlencoded)"))
             elif primary_content_type == "application/json":
                 body_type = get_request_body_type(op.request_body, context, self.schemas)
                 args.append(("body", body_type, body_desc + " (json)"))

pyopenapi_gen/visit/endpoint/generators/request_generator.py

@@ -5,7 +5,7 @@ Helper class for generating the HTTP request call for an endpoint method.
 from __future__ import annotations
 
 import logging
-from typing import TYPE_CHECKING, Any, Dict, Optional
+from typing import TYPE_CHECKING, Any
 
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
 
@@ -21,8 +21,8 @@ logger = logging.getLogger(__name__)
 class EndpointRequestGenerator:
     """Generates the self._transport.request(...) call 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 generate_request_call(
         self,
@@ -30,8 +30,8 @@ class EndpointRequestGenerator:
         op: IROperation,
         context: RenderContext,  # Pass context for potential import needs
         has_header_params: bool,
-        primary_content_type: Optional[str],
-        # resolved_body_type: Optional[str], # May not be directly needed here if logic relies on var names
+        primary_content_type: str | None,
+        # resolved_body_type: str | None, # May not be directly needed here if logic relies on var names
     ) -> None:
         """Writes the self._transport.request call to the CodeWriter."""
         # Logic from EndpointMethodGenerator._write_request