pyopenapi-gen 2.7.2__py3-none-any.whl

pyopenapi_gen/visit/endpoint/generators/mock_generator.py

@@ -0,0 +1,140 @@
+"""
+Generator for creating mock method implementations.
+
+This module generates mock methods that raise NotImplementedError,
+allowing users to create test doubles by subclassing and overriding
+only the methods they need.
+"""
+
+from typing import Any
+
+from ....context.render_context import RenderContext
+from ....core.utils import NameSanitizer
+from ....core.writers.code_writer import CodeWriter
+from ....ir import IROperation
+from .endpoint_method_generator import EndpointMethodGenerator
+
+
+class MockGenerator:
+    """
+    Generates mock method implementations for testing.
+
+    Mock methods preserve the exact signature of the real implementation
+    but raise NotImplementedError with helpful error messages instead
+    of performing actual operations.
+    """
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas = schemas or {}
+        self.method_generator = EndpointMethodGenerator(self.schemas)
+
+    def generate(self, op: IROperation, context: RenderContext) -> str:
+        """
+        Generate a mock method that raises NotImplementedError.
+
+        Args:
+            op: The operation to generate a mock for
+            context: Render context for import tracking
+
+        Returns:
+            Complete mock method code as string
+        """
+        # Generate the full method using EndpointMethodGenerator
+        full_method = self.method_generator.generate(op, context)
+
+        # Parse and transform it to a mock implementation
+        return self._transform_to_mock(full_method, op)
+
+    def _transform_to_mock(self, full_method_code: str, op: IROperation) -> str:
+        """
+        Transform a full method implementation into a mock that raises NotImplementedError.
+
+        Args:
+            full_method_code: Complete method code from EndpointMethodGenerator
+            op: The operation (for generating error messages)
+
+        Returns:
+            Mock method code with NotImplementedError body
+        """
+        lines = full_method_code.split("\n")
+        writer = CodeWriter()
+
+        i = 0
+        while i < len(lines):
+            line = lines[i]
+            stripped = line.strip()
+
+            # Handle @overload decorator - keep it
+            if stripped.startswith("@overload"):
+                writer.write_line(stripped)
+                i += 1
+
+                # Copy overload signature until we hit `: ...`
+                while i < len(lines):
+                    sig_line = lines[i]
+                    sig_stripped = sig_line.strip()
+                    writer.write_line(sig_stripped)
+
+                    if sig_stripped.endswith(": ..."):
+                        writer.write_line("")  # Blank line after overload
+                        i += 1
+                        break
+
+                    i += 1
+                continue
+
+            # Handle method definition (async def or def)
+            if (stripped.startswith("async def ") or stripped.startswith("def ")) and "(" in stripped:
+                # Determine if this is an async generator
+                is_async_generator = False
+
+                # Collect signature lines to check return type
+                signature_lines = []
+                temp_i = i
+                while temp_i < len(lines):
+                    sig_stripped = lines[temp_i].strip()
+                    signature_lines.append(sig_stripped)
+                    if sig_stripped.endswith(":") and not sig_stripped.endswith(","):
+                        # Check if AsyncIterator in return type
+                        full_sig = " ".join(signature_lines)
+                        is_async_generator = "AsyncIterator" in full_sig
+                        break
+                    temp_i += 1
+
+                # Write signature lines
+                for sig in signature_lines:
+                    writer.write_line(sig)
+
+                # Write mock body
+                writer.indent()
+
+                # Docstring
+                writer.write_line('"""')
+                writer.write_line("Mock implementation that raises NotImplementedError.")
+                writer.write_line("")
+                writer.write_line("Override this method in your test subclass to provide")
+                writer.write_line("the behavior needed for your test scenario.")
+                writer.write_line('"""')
+
+                # Error message
+                method_name = NameSanitizer.sanitize_method_name(op.operation_id)
+                tag = op.tags[0] if op.tags else "Client"
+                class_name = f"Mock{NameSanitizer.sanitize_class_name(tag)}Client"
+                error_msg = (
+                    f'"{class_name}.{method_name}() not implemented. ' f'Override this method in your test subclass."'
+                )
+                writer.write_line(f"raise NotImplementedError({error_msg})")
+
+                # For async generators, add unreachable yield for type checker
+                if is_async_generator:
+                    writer.write_line("yield  # pragma: no cover")
+
+                writer.dedent()
+
+                # Skip the rest of this method implementation in the original code
+                i = len(lines)  # Exit the loop
+                break
+
+            i += 1
+
+        return writer.get_code()

pyopenapi_gen/visit/endpoint/generators/overload_generator.py

@@ -0,0 +1,252 @@
+"""Generator for @overload signatures when operations have multiple content types."""
+
+import logging
+from typing import Any
+
+from pyopenapi_gen import IROperation
+
+from ....context.render_context import RenderContext
+from ....core.utils import NameSanitizer
+from ....core.writers.code_writer import CodeWriter
+from ..processors.parameter_processor import EndpointParameterProcessor
+from .docstring_generator import EndpointDocstringGenerator
+from .signature_generator import EndpointMethodSignatureGenerator
+
+logger = logging.getLogger(__name__)
+
+
+class OverloadMethodGenerator:
+    """
+    Generates @overload signatures for operations with multiple content types.
+
+    When an operation's request body accepts multiple content types
+    (e.g., application/json and multipart/form-data), this generator creates
+    type-safe @overload signatures following PEP 484.
+    """
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas = schemas or {}
+        self.parameter_processor = EndpointParameterProcessor(self.schemas)
+        self.signature_generator = EndpointMethodSignatureGenerator(self.schemas)
+        self.docstring_generator = EndpointDocstringGenerator(self.schemas)
+
+    def has_multiple_content_types(self, op: IROperation) -> bool:
+        """
+        Check if operation request body has multiple content types.
+
+        Args:
+            op: The operation to check
+
+        Returns:
+            True if operation has request body with multiple content types
+        """
+        if not op.request_body:
+            return False
+        return len(op.request_body.content) > 1
+
+    def generate_overload_signatures(
+        self, op: IROperation, context: RenderContext, response_strategy: Any
+    ) -> list[str]:
+        """
+        Generate @overload signatures for each content type.
+
+        Args:
+            op: The operation with multiple content types
+            context: Render context for import tracking
+            response_strategy: Response strategy for return type resolution
+
+        Returns:
+            List of @overload signature code strings
+        """
+        if not self.has_multiple_content_types(op):
+            return []
+
+        # Ensure typing.overload is imported
+        context.add_import("typing", "overload")
+        context.add_import("typing", "Literal")
+        context.add_import("typing", "IO")
+        context.add_import("typing", "Any")
+
+        overload_signatures = []
+
+        # Type narrowing: request_body is guaranteed to exist by has_multiple_content_types check
+        assert (
+            op.request_body is not None
+        ), "request_body should not be None after has_multiple_content_types check"  # nosec B101 - Type narrowing for mypy, validated by has_multiple_content_types
+
+        for content_type, schema in op.request_body.content.items():
+            signature_code = self._generate_single_overload(op, content_type, schema, context, response_strategy)
+            overload_signatures.append(signature_code)
+
+        return overload_signatures
+
+    def _generate_single_overload(
+        self,
+        op: IROperation,
+        content_type: str,
+        schema: Any,
+        context: RenderContext,
+        response_strategy: Any,
+    ) -> str:
+        """
+        Generate a single @overload signature for one content type.
+
+        Args:
+            op: The operation
+            content_type: The media type (e.g., "application/json")
+            schema: The schema for this content type
+            context: Render context
+            response_strategy: Response strategy for return type
+
+        Returns:
+            @overload signature code as string
+        """
+        writer = CodeWriter()
+
+        # Write @overload decorator
+        writer.write_line("@overload")
+
+        # Determine parameter name and type based on content type
+        param_info = self._get_content_type_param_info(content_type, schema, context)
+
+        # Build parameter list from operation parameters directly
+        param_parts = ["self"]
+
+        # Add path, query, and header parameters from operation
+        if op.parameters:
+            from ....types.services.type_service import UnifiedTypeService
+
+            type_service = UnifiedTypeService(self.schemas)
+
+            for param in op.parameters:
+                if param.param_in in ("path", "query", "header"):
+                    param_type = type_service.resolve_schema_type(param.schema, context, required=param.required)
+                    sanitized_name = NameSanitizer.sanitize_method_name(param.name)
+                    param_parts.append(f"{sanitized_name}: {param_type}")
+
+        # Add keyword-only separator
+        param_parts.append("*")
+
+        # Add content-type-specific parameter
+        param_parts.append(f"{param_info['name']}: {param_info['type']}")
+
+        # Add content_type parameter with Literal type
+        param_parts.append(f'content_type: Literal["{content_type}"] = "{content_type}"')
+
+        # Get return type from response strategy
+        return_type = response_strategy.return_type
+
+        # Sanitize method name to snake_case
+        method_name = NameSanitizer.sanitize_method_name(op.operation_id)
+
+        # Write signature
+        params_str = ",\n    ".join(param_parts)
+        writer.write_line(f"async def {method_name}(")
+        writer.indent()
+        writer.write_line(params_str)
+        writer.dedent()
+        writer.write_line(f") -> {return_type}: ...")
+
+        return writer.get_code()
+
+    def _get_content_type_param_info(self, content_type: str, schema: Any, context: RenderContext) -> dict[str, str]:
+        """
+        Get parameter name and type hint for a content type.
+
+        Args:
+            content_type: Media type string
+            schema: Schema for this content type
+            context: Render context for type resolution
+
+        Returns:
+            Dictionary with 'name' and 'type' keys
+        """
+        from ....types.services.type_service import UnifiedTypeService
+
+        type_service = UnifiedTypeService(self.schemas)
+
+        # Map content types to parameter names and base types
+        if content_type == "application/json":
+            # For JSON, resolve the actual schema type
+            type_hint = type_service.resolve_schema_type(schema, context, required=True)
+            return {"name": "body", "type": type_hint}
+
+        elif content_type == "multipart/form-data":
+            # For multipart, always use files dict
+            return {"name": "files", "type": "dict[str, IO[Any]]"}
+
+        elif content_type == "application/x-www-form-urlencoded":
+            # For form data, use dict
+            return {"name": "data", "type": "dict[str, str]"}
+
+        else:
+            # Default: use body with Any type
+            logger.warning(f"Unknown content type {content_type}, using body: Any")
+            return {"name": "body", "type": "Any"}
+
+    def generate_implementation_signature(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """
+        Generate the actual implementation method signature with optional parameters.
+
+        This signature accepts all possible content-type parameters as optional,
+        and includes runtime dispatch logic.
+
+        Args:
+            op: The operation
+            context: Render context
+            response_strategy: Response strategy for return type
+
+        Returns:
+            Implementation method signature code
+        """
+        writer = CodeWriter()
+
+        # Build parameter list
+        param_parts = ["self"]
+
+        # Add path, query, and header parameters from operation
+        if op.parameters:
+            from ....types.services.type_service import UnifiedTypeService
+
+            type_service = UnifiedTypeService(self.schemas)
+
+            for param in op.parameters:
+                if param.param_in in ("path", "query", "header"):
+                    param_type = type_service.resolve_schema_type(param.schema, context, required=param.required)
+                    sanitized_name = NameSanitizer.sanitize_method_name(param.name)
+                    param_parts.append(f"{sanitized_name}: {param_type}")
+
+        # Add keyword-only separator
+        param_parts.append("*")
+
+        # Add all possible content-type parameters as optional
+        if op.request_body:
+            param_types_seen = set()
+
+            for content_type, schema in op.request_body.content.items():
+                param_info = self._get_content_type_param_info(content_type, schema, context)
+
+                # Avoid duplicate parameters (e.g., if multiple JSON variants)
+                param_key = param_info["name"]
+                if param_key not in param_types_seen:
+                    param_parts.append(f"{param_info['name']}: {param_info['type']} | None = None")
+                    param_types_seen.add(param_key)
+
+        # Add content_type parameter (no Literal, just str)
+        param_parts.append('content_type: str = "application/json"')
+
+        # Get return type
+        return_type = response_strategy.return_type
+
+        # Sanitize method name to snake_case
+        method_name = NameSanitizer.sanitize_method_name(op.operation_id)
+
+        # Write signature
+        params_str = ",\n    ".join(param_parts)
+        writer.write_line(f"async def {method_name}(")
+        writer.indent()
+        writer.write_line(params_str)
+        writer.dedent()
+        writer.write_line(f") -> {return_type}:")
+
+        return writer.get_code()

pyopenapi_gen/visit/endpoint/generators/request_generator.py

@@ -0,0 +1,103 @@
+"""
+Helper class for generating the HTTP request call for an endpoint method.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any
+
+from pyopenapi_gen.core.writers.code_writer import CodeWriter
+
+# No specific utils needed yet, but NameSanitizer might be if param names are manipulated here
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IROperation
+    from pyopenapi_gen.context.render_context import RenderContext  # For context.add_import if needed
+
+logger = logging.getLogger(__name__)
+
+
+class EndpointRequestGenerator:
+    """Generates the self._transport.request(...) call for an endpoint method."""
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
+
+    def generate_request_call(
+        self,
+        writer: CodeWriter,
+        op: IROperation,
+        context: RenderContext,  # Pass context for potential import needs
+        has_header_params: bool,
+        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
+        args_list = []
+
+        # Determine if 'params' argument is needed for query parameters
+        # This relies on UrlArgsGenerator having created a 'params' dict if query params exist.
+        # A more robust way could be to check op.parameters directly, but this keeps coupling loose.
+        if any(p.param_in == "query" for p in op.parameters):  # Check IROperation directly for query params
+            args_list.append("params=params")
+        else:
+            args_list.append("params=None")
+
+        # Determine 'json' and 'data' arguments based on request body
+        if op.request_body:
+            if primary_content_type == "application/json":
+                args_list.append("json=json_body")  # Assumes json_body is defined
+                # args_list.append("data=None") # Not strictly needed if json is present, httpx handles it
+            elif primary_content_type and "multipart/form-data" in primary_content_type:
+                # For multipart, httpx uses 'files' or 'data' depending on content.
+                # UrlArgsGenerator created 'files_data'. Httpx typically uses 'files=' for file uploads.
+                # Let's assume 'files_data' is a dict suitable for 'files=' or 'data='
+                # If 'files_data' is specifically for file-like objects, 'files=files_data' is better.
+                # If it can also contain plain data, 'data=files_data' might be used by httpx.
+                # For simplicity and common use with files:
+                args_list.append("files=files_data")  # Assumes files_data is defined
+            elif primary_content_type == "application/x-www-form-urlencoded":
+                args_list.append("data=form_data_body")  # Assumes form_data_body is defined
+            elif primary_content_type:  # Other types, like application/octet-stream
+                args_list.append("data=bytes_body")  # Assumes bytes_body is defined
+            # else: # No specific content type handled, might mean no body or unhandled type
+            #     args_list.append("json=None")
+            #     args_list.append("data=None")
+        else:  # No request body
+            args_list.append("json=None")
+            args_list.append("data=None")
+
+        # Determine 'headers' argument
+        if has_header_params:  # This flag comes from UrlArgsGenerator
+            args_list.append("headers=headers")  # Assumes headers dict is defined
+        else:
+            args_list.append("headers=None")
+
+        positional_args_str = f'"{op.method.upper()}", url'  # url variable is assumed to be defined
+        keyword_args_str = ", ".join(args_list)
+
+        # Check length for formatting (120 is a common line length limit)
+        # Account for "response = await self._transport.request(" and ")" and surrounding spaces/indentation
+        # A rough estimate, effective line length for arguments should be less than ~120 - ~40 = 80
+        effective_args_len = len(positional_args_str) + len(", ") + len(keyword_args_str)
+
+        base_call_len = len("response = await self._transport.request()") + 2  # +2 for (,)
+
+        if base_call_len + effective_args_len <= 100:  # Adjusted for typical black formatting preference
+            writer.write_line(f"response = await self._transport.request({positional_args_str}, {keyword_args_str})")
+        else:
+            writer.write_line(f"response = await self._transport.request(")
+            writer.indent()
+            writer.write_line(f"{positional_args_str},")
+            # Filter out "*=None" for cleaner multi-line calls if they are truly None and not just assigned None
+            # This might be overly complex here; httpx handles None correctly.
+            # Sticking to original logic for now.
+            num_args = len(args_list)
+            for i, arg in enumerate(args_list):
+                line_end = "," if i < num_args - 1 else ""
+                writer.write_line(f"{arg}{line_end}")
+            writer.dedent()
+            writer.write_line(")")
+        writer.write_line("")  # Add a blank line for readability after the request call