pyopenapi-gen 0.8.3__py3-none-any.whl → 0.8.6__py3-none-any.whl

pyopenapi_gen/types/contracts/types.py

@@ -20,7 +20,6 @@ class ResolvedType:
     import_name: Optional[str] = None
     is_optional: bool = False
     is_forward_ref: bool = False
-    was_unwrapped: bool = False
 
     def __post_init__(self) -> None:
         """Validate resolved type data."""

pyopenapi_gen/types/resolvers/response_resolver.py

@@ -58,28 +58,21 @@ class OpenAPIResponseResolver(ResponseTypeResolver):
         if hasattr(response, "ref") and response.ref:
             return self._resolve_response_reference(response.ref, context)
 
+        # Handle streaming responses (check before content validation)
+        if hasattr(response, "stream") and response.stream:
+            return self._resolve_streaming_response(response, context)
+
         # Handle responses without content (e.g., 204)
         if not hasattr(response, "content") or not response.content:
             return ResolvedType(python_type="None")
 
-        # Handle streaming responses
-        if hasattr(response, "stream") and response.stream:
-            return self._resolve_streaming_response(response, context)
-
         # Get the content schema
         schema = self._get_response_schema(response)
         if not schema:
             return ResolvedType(python_type="None")
 
-        # Resolve the schema
+        # Resolve the schema directly (no unwrapping)
         resolved = self.schema_resolver.resolve_schema(schema, context, required=True)
-
-        # Check for data unwrapping
-        unwrapped = self._try_unwrap_data_property(schema, context)
-        if unwrapped:
-            unwrapped.was_unwrapped = True
-            return unwrapped
-
         return resolved
 
     def _resolve_response_reference(self, ref: str, context: TypeContext) -> ResolvedType:
@@ -136,27 +129,6 @@ class OpenAPIResponseResolver(ResponseTypeResolver):
 
         return response.content.get(content_type)
 
-    def _try_unwrap_data_property(self, schema: IRSchema | None, context: TypeContext) -> Optional[ResolvedType]:
-        """
-        Try to unwrap a 'data' property if the schema is a wrapper.
-
-        Returns unwrapped type or None if not applicable.
-        """
-        if not schema or not hasattr(schema, "type") or schema.type != "object":
-            return None
-
-        properties = getattr(schema, "properties", None)
-        if not properties or len(properties) != 1:
-            return None
-
-        # Check for 'data' property
-        data_property = properties.get("data")
-        if not data_property:
-            return None
-
-        logger.info(f"Unwrapping 'data' property from response schema")
-        return self.schema_resolver.resolve_schema(data_property, context, required=True)
-
     def _resolve_streaming_response(self, response: IRResponse, context: TypeContext) -> ResolvedType:
         """
         Resolve a streaming response to an AsyncIterator type.

pyopenapi_gen/types/resolvers/schema_resolver.py

@@ -307,7 +307,7 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         # Sort types for consistent ordering
         resolved_types.sort()
         context.add_import("typing", "Union")
-        union_type = f"Union[{', '.join(resolved_types)}]"
+        union_type = f"Union[{", ".join(resolved_types)}]"
 
         return ResolvedType(python_type=union_type, is_optional=not required)
 
@@ -362,6 +362,6 @@ class OpenAPISchemaResolver(SchemaTypeResolver):
         # Sort types for consistent ordering
         resolved_types.sort()
         context.add_import("typing", "Union")
-        union_type = f"Union[{', '.join(resolved_types)}]"
+        union_type = f"Union[{", ".join(resolved_types)}]"
 
         return ResolvedType(python_type=union_type, is_optional=not required)

pyopenapi_gen/types/services/type_service.py

@@ -85,24 +85,6 @@ class UnifiedTypeService:
         resolved = self.response_resolver.resolve_operation_response(operation, type_context)
         return self._format_resolved_type(resolved, context)
 
-    def resolve_operation_response_with_unwrap_info(
-        self, operation: IROperation, context: RenderContext
-    ) -> tuple[str, bool]:
-        """
-        Resolve an operation's response to a Python type string with unwrapping information.
-
-        Args:
-            operation: The operation to resolve
-            context: Render context for imports
-
-        Returns:
-            Tuple of (Python type string, was_unwrapped flag)
-        """
-        type_context = RenderContextAdapter(context)
-        resolved = self.response_resolver.resolve_operation_response(operation, type_context)
-        python_type = self._format_resolved_type(resolved, context)
-        return python_type, resolved.was_unwrapped
-
     def resolve_response_type(self, response: IRResponse, context: RenderContext) -> str:
         """
         Resolve a specific response to a Python type string.

pyopenapi_gen/types/strategies/__init__.py

@@ -0,0 +1,5 @@
+"""Response handling strategies."""
+
+from .response_strategy import ResponseStrategy, ResponseStrategyResolver
+
+__all__ = ["ResponseStrategy", "ResponseStrategyResolver"]

pyopenapi_gen/types/strategies/response_strategy.py

@@ -0,0 +1,187 @@
+"""Unified response handling strategy.
+
+This module provides a single source of truth for how operation responses should be handled,
+eliminating the scattered responsibility that was causing Data_ vs proper schema name issues.
+"""
+
+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
+from pyopenapi_gen.types.services.type_service import UnifiedTypeService
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ResponseStrategy:
+    """Unified strategy for handling a specific operation's response.
+
+    This class encapsulates all decisions about how to handle a response:
+    - What type to use in method signatures (matches OpenAPI schema exactly)
+    - Which schema to use for deserialization
+    - How to generate the response handling code
+    """
+
+    return_type: str  # The Python type for method signature
+    response_schema: Optional[IRSchema]  # 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
+
+
+class ResponseStrategyResolver:
+    """Single source of truth for response handling decisions.
+
+    This resolver examines an operation and its responses to determine the optimal
+    strategy for handling the response. It replaces the scattered logic that was
+    previously spread across multiple components.
+    """
+
+    def __init__(self, schemas: Dict[str, IRSchema]):
+        self.schemas = schemas
+        self.type_service = UnifiedTypeService(schemas)
+
+    def resolve(self, operation: IROperation, context: RenderContext) -> ResponseStrategy:
+        """Determine how to handle this operation's response.
+
+        Uses the response schema exactly as defined in the OpenAPI spec,
+        with no unwrapping logic. What you see in the spec is what you get.
+
+        Args:
+            operation: The operation to analyze
+            context: Render context for type resolution
+
+        Returns:
+            A ResponseStrategy that all components should use consistently
+        """
+        primary_response = self._get_primary_response(operation)
+
+        if not primary_response:
+            return ResponseStrategy(return_type="None", response_schema=None, is_streaming=False, response_ir=None)
+
+        # Handle responses without content (e.g., 204)
+        if not hasattr(primary_response, "content") or not primary_response.content:
+            return ResponseStrategy(
+                return_type="None", response_schema=None, is_streaming=False, response_ir=primary_response
+            )
+
+        # Handle streaming responses
+        if hasattr(primary_response, "stream") and primary_response.stream:
+            return self._resolve_streaming_strategy(primary_response, context)
+
+        # Get the response schema
+        response_schema = self._get_response_schema(primary_response)
+        if not response_schema:
+            return ResponseStrategy(
+                return_type="None", response_schema=None, is_streaming=False, response_ir=primary_response
+            )
+
+        # Use the response schema as-is from the OpenAPI spec
+        return_type = self.type_service.resolve_schema_type(response_schema, context, required=True)
+
+        return ResponseStrategy(
+            return_type=return_type, response_schema=response_schema, is_streaming=False, response_ir=primary_response
+        )
+
+    def _get_primary_response(self, operation: IROperation) -> Optional[IRResponse]:
+        """Get the primary success response from an operation."""
+        if not operation.responses:
+            return None
+
+        # Priority order: 200, 201, 202, 204, other 2xx, default
+        for code in ["200", "201", "202", "204"]:
+            for response in operation.responses:
+                if response.status_code == code:
+                    return response
+
+        # Other 2xx responses
+        for response in operation.responses:
+            if response.status_code.startswith("2"):
+                return response
+
+        # Default response
+        for response in operation.responses:
+            if response.status_code == "default":
+                return response
+
+        # First response as fallback
+        return operation.responses[0] if operation.responses else None
+
+    def _get_response_schema(self, response: IRResponse) -> Optional[IRSchema]:
+        """Get the schema from a response's content."""
+        if not response.content:
+            return None
+
+        # Prefer application/json
+        content_types = list(response.content.keys())
+        content_type = None
+
+        if "application/json" in content_types:
+            content_type = "application/json"
+        elif any("json" in ct for ct in content_types):
+            content_type = next(ct for ct in content_types if "json" in ct)
+        elif content_types:
+            content_type = content_types[0]
+
+        if not content_type:
+            return None
+
+        return response.content.get(content_type)
+
+    def _resolve_streaming_strategy(self, response: IRResponse, context: RenderContext) -> ResponseStrategy:
+        """Resolve strategy for streaming responses."""
+        # Add AsyncIterator import
+        context.add_import("typing", "AsyncIterator")
+
+        # Determine the item type for the stream
+        if not response.content:
+            # Binary stream with no specific content type
+            return ResponseStrategy(
+                return_type="AsyncIterator[bytes]", response_schema=None, is_streaming=True, response_ir=response
+            )
+
+        # Check for binary content types
+        content_types = list(response.content.keys())
+        is_binary = any(
+            ct in ["application/octet-stream", "application/pdf"] or ct.startswith(("image/", "audio/", "video/"))
+            for ct in content_types
+        )
+
+        if is_binary:
+            return ResponseStrategy(
+                return_type="AsyncIterator[bytes]", response_schema=None, is_streaming=True, response_ir=response
+            )
+
+        # 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 ResponseStrategy(
+                return_type="AsyncIterator[Dict[str, Any]]",
+                response_schema=None,
+                is_streaming=True,
+                response_ir=response,
+            )
+
+        # For other streaming content, try to resolve the schema
+        schema = self._get_response_schema(response)
+        if schema:
+            schema_type = self.type_service.resolve_schema_type(schema, context, required=True)
+            return ResponseStrategy(
+                return_type=f"AsyncIterator[{schema_type}]",
+                response_schema=schema,
+                is_streaming=True,
+                response_ir=response,
+            )
+
+        # Default to bytes if we can't determine the type
+        return ResponseStrategy(
+            return_type="AsyncIterator[bytes]", response_schema=None, is_streaming=True, response_ir=response
+        )

pyopenapi_gen/visit/endpoint/endpoint_visitor.py

@@ -2,10 +2,8 @@ import logging
 from typing import Any
 
 from pyopenapi_gen import IROperation
-from pyopenapi_gen.helpers.endpoint_utils import (
-    get_return_type_unified,
-)
 
+# No longer need endpoint utils helpers - using ResponseStrategy pattern
 from ...context.render_context import RenderContext
 from ...core.utils import NameSanitizer
 from ...core.writers.code_writer import CodeWriter
@@ -84,20 +82,3 @@ class EndpointVisitor(Visitor[IROperation, str]):
 
         writer.dedent()  # Dedent to close the class block
         return writer.get_code()
-
-    def _get_response_return_type_details(self, context: RenderContext, op: IROperation) -> tuple[str, bool, bool, str]:
-        """Gets type details for the endpoint response."""
-        # Check if this is a streaming response (either at op level or in schema)
-        is_streaming = any(getattr(resp, "stream", False) for resp in op.responses if resp.status_code.startswith("2"))
-
-        # Get the primary Python type for the operation's success response using unified service
-        return_type = get_return_type_unified(op, context, self.schemas)
-        should_unwrap = False  # Unified service handles unwrapping internally
-
-        # Determine the summary description (for docstring)
-        success_resp = next((r for r in op.responses if r.status_code.startswith("2")), None)
-        return_description = (
-            success_resp.description if success_resp and success_resp.description else "Successful operation"
-        )
-
-        return return_type, should_unwrap, is_streaming, return_description

pyopenapi_gen/visit/endpoint/generators/docstring_generator.py

@@ -10,11 +10,12 @@ from typing import TYPE_CHECKING, Any, Dict, Optional
 
 from pyopenapi_gen.core.writers.code_writer import CodeWriter
 from pyopenapi_gen.core.writers.documentation_writer import DocumentationBlock, DocumentationWriter
-from pyopenapi_gen.helpers.endpoint_utils import get_param_type, get_request_body_type, get_return_type_unified
+from pyopenapi_gen.helpers.endpoint_utils import get_param_type, get_request_body_type
 
 if TYPE_CHECKING:
     from pyopenapi_gen import IROperation
     from pyopenapi_gen.context.render_context import RenderContext
+    from pyopenapi_gen.types.strategies.response_strategy import ResponseStrategy
 
 logger = logging.getLogger(__name__)
 
@@ -50,6 +51,7 @@ class EndpointDocstringGenerator:
         op: IROperation,
         context: RenderContext,
         primary_content_type: Optional[str],
+        response_strategy: ResponseStrategy,
     ) -> None:
         """Writes the method docstring to the provided CodeWriter."""
         summary = op.summary or None
@@ -75,7 +77,7 @@ class EndpointDocstringGenerator:
             else:  # Fallback for other types like application/octet-stream
                 args.append(("bytes_content", "bytes", body_desc + f" ({primary_content_type})"))
 
-        return_type = get_return_type_unified(op, context, self.schemas)
+        return_type = response_strategy.return_type
         response_desc = None
         # Prioritize 2xx success codes for the main response description
         for code in ("200", "201", "202", "default"):  # Include default as it might be the success response
@@ -97,7 +99,7 @@ class EndpointDocstringGenerator:
             for resp in error_codes:
                 # Using a generic HTTPError, specific error classes could be mapped later
                 code_to_raise = "HTTPError"
-                desc = f"{resp.status_code}: {resp.description.strip() if resp.description else 'HTTP error.'}"
+                desc = f"{resp.status_code}: {resp.description.strip() if resp.description else "HTTP error."}"
                 raises.append((code_to_raise, desc))
         else:
             raises.append(("HTTPError", "If the server returns a non-2xx HTTP response."))

pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py

@@ -6,6 +6,7 @@ from pyopenapi_gen import IROperation
 from ....context.render_context import RenderContext
 from ....core.utils import Formatter
 from ....core.writers.code_writer import CodeWriter
+from ....types.strategies import ResponseStrategyResolver
 from ..processors.import_analyzer import EndpointImportAnalyzer
 from ..processors.parameter_processor import EndpointParameterProcessor
 from .docstring_generator import EndpointDocstringGenerator
@@ -43,16 +44,21 @@ class EndpointMethodGenerator:
         context.add_import(f"{context.core_package_name}.http_transport", "HttpTransport")
         context.add_import(f"{context.core_package_name}.exceptions", "HTTPError")
 
-        # Special case for updateAgentDataSource was removed.
+        # UNIFIED RESPONSE STRATEGY: Resolve once, use everywhere
+        strategy_resolver = ResponseStrategyResolver(self.schemas)
+        response_strategy = strategy_resolver.resolve(op, context)
 
-        self.import_analyzer.analyze_and_register_imports(op, context)
+        # Pass the response strategy to import analyzer for consistent import resolution
+        self.import_analyzer.analyze_and_register_imports(op, context, response_strategy)
 
         ordered_params, primary_content_type, resolved_body_type = self.parameter_processor.process_parameters(
             op, context
         )
-        self.signature_generator.generate_signature(writer, op, context, ordered_params)
 
-        self.docstring_generator.generate_docstring(writer, op, context, primary_content_type)
+        # Pass strategy to generators for consistent behavior
+        self.signature_generator.generate_signature(writer, op, context, ordered_params, response_strategy)
+
+        self.docstring_generator.generate_docstring(writer, op, context, primary_content_type, response_strategy)
 
         # Snapshot of code *before* main body parts are written
         # This includes signature and docstring.
@@ -63,8 +69,8 @@ class EndpointMethodGenerator:
         )
         self.request_generator.generate_request_call(writer, op, context, has_header_params, primary_content_type)
 
-        # Call the new response handler generator
-        self.response_handler_generator.generate_response_handling(writer, op, context)
+        # Call the new response handler generator with strategy
+        self.response_handler_generator.generate_response_handling(writer, op, context, response_strategy)
 
         # Check if any actual statements were added for the body
         current_full_code = writer.get_code()