pyopenapi-gen 2.7.2__py3-none-any.whl

pyopenapi_gen/visit/endpoint/endpoint_visitor.py

@@ -0,0 +1,292 @@
+import logging
+from typing import Any
+
+from pyopenapi_gen import IROperation
+
+# 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
+from ..visitor import Visitor
+from .generators.endpoint_method_generator import EndpointMethodGenerator
+
+# Get logger instance
+logger = logging.getLogger(__name__)
+
+
+class EndpointVisitor(Visitor[IROperation, str]):
+    """
+    Visitor for rendering a Python endpoint client method/class from an IROperation.
+    The method generation part is delegated to EndpointMethodGenerator.
+    This class remains responsible for assembling methods into a class (emit_endpoint_client_class).
+    Returns the rendered code as a string (does not write files).
+    """
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas = schemas or {}
+        # Formatter is likely not needed here anymore if all formatting happens in EndpointMethodGenerator
+        # self.formatter = Formatter()
+
+    def visit_IROperation(self, op: IROperation, context: RenderContext) -> str:
+        """
+        Generate a fully functional async endpoint method for the given operation
+        by delegating to EndpointMethodGenerator.
+        Returns the method code as a string.
+        """
+        # Instantiate the new generator
+        method_generator = EndpointMethodGenerator(schemas=self.schemas)
+        return method_generator.generate(op, context)
+
+    def emit_endpoint_client_class(
+        self,
+        tag: str,
+        method_codes: list[str],
+        context: RenderContext,
+        operations: list[IROperation] | None = None,
+    ) -> str:
+        """
+        Emit the endpoint client class for a tag, aggregating all endpoint methods.
+        The generated class is fully type-annotated and uses HttpTransport for HTTP communication.
+        Args:
+            tag: The tag name for the endpoint group.
+            method_codes: List of method code blocks as strings.
+            context: The RenderContext for import tracking.
+            operations: List of operations for Protocol generation (optional for backwards compatibility).
+        """
+        # Generate Protocol if operations provided
+        protocol_code = ""
+        if operations:
+            protocol_code = self.generate_endpoint_protocol(tag, operations, context)
+
+        # Generate implementation
+        impl_code = self._generate_endpoint_implementation(tag, method_codes, context)
+
+        # Combine Protocol and implementation
+        if protocol_code:
+            return f"{protocol_code}\n\n\n{impl_code}"
+        else:
+            return impl_code
+
+    def generate_endpoint_protocol(self, tag: str, operations: list[IROperation], context: RenderContext) -> str:
+        """
+        Generate Protocol definition for tag-based endpoint client.
+
+        Args:
+            tag: The tag name for the endpoint group
+            operations: List of operations for this tag
+            context: Render context for import management
+
+        Returns:
+            Protocol class code as string with all operation method signatures
+        """
+        # Register Protocol imports
+        context.add_import("typing", "Protocol")
+        context.add_import("typing", "runtime_checkable")
+
+        writer = CodeWriter()
+        class_name = NameSanitizer.sanitize_class_name(tag) + "Client"
+        protocol_name = f"{class_name}Protocol"
+
+        # Protocol class header
+        writer.write_line("@runtime_checkable")
+        writer.write_line(f"class {protocol_name}(Protocol):")
+        writer.indent()
+
+        # Docstring
+        writer.write_line(f'"""Protocol defining the interface of {class_name} for dependency injection."""')
+        writer.write_line("")
+
+        # Generate method signatures from operations
+        # We need to extract complete signatures including multi-line ones and decorators
+        # For Protocol, we only include the method signatures with ..., not implementations
+        # IMPORTANT: Preserve multi-line formatting for readability
+        for op in operations:
+            method_generator = EndpointMethodGenerator(schemas=self.schemas)
+            full_method_code = method_generator.generate(op, context)
+
+            # Parse the generated code to extract method signatures
+            # We want: @overload stubs (already have ...) and final signature converted to stub
+            lines = full_method_code.split("\n")
+            i = 0
+
+            while i < len(lines):
+                line = lines[i]
+                stripped = line.strip()
+
+                # Handle @overload decorator
+                if stripped.startswith("@overload"):
+                    # Write decorator
+                    writer.write_line(stripped)
+                    i += 1
+
+                    # Now process the signature following the decorator
+                    # Keep collecting lines until we hit the end of the overload signature
+                    while i < len(lines):
+                        sig_line = lines[i]
+                        sig_stripped = sig_line.strip()
+
+                        # Write each line of the signature
+                        writer.write_line(sig_stripped)
+
+                        # Check for end of overload signature (ends with `: ...`)
+                        if sig_stripped.endswith(": ..."):
+                            writer.write_line("")  # Blank line after overload
+                            i += 1
+                            break
+
+                        i += 1
+                    continue
+
+                # Handle non-overload method signatures (the final implementation signature)
+                if stripped.startswith("async def ") and "(" in stripped:
+                    # This is the start of a method signature
+                    # We need to collect all lines until we hit the colon
+                    signature_lines = []
+
+                    # Collect signature lines
+                    while i < len(lines):
+                        sig_line = lines[i]
+                        sig_stripped = sig_line.strip()
+
+                        signature_lines.append(sig_stripped)
+
+                        # Check if this completes the signature (ends with :)
+                        if sig_stripped.endswith(":") and not sig_stripped.endswith(","):
+                            # This is the final line of the signature
+                            # For Protocol, convert to stub format
+
+                            # Check if this is an async generator (returns AsyncIterator)
+                            # If so, remove 'async' from the first line
+                            is_async_generator = "AsyncIterator" in sig_stripped
+
+                            # Write all lines except the last
+                            for idx, sig in enumerate(signature_lines[:-1]):
+                                # For async generators, remove 'async ' from method definition
+                                if idx == 0 and is_async_generator and sig.startswith("async def "):
+                                    sig = sig.replace("async def ", "def ", 1)
+                                writer.write_line(sig)
+
+                            # Write last line with ... instead of :
+                            last_line = signature_lines[-1]
+                            if last_line.endswith(":"):
+                                last_line = last_line[:-1]  # Remove trailing :
+                            writer.write_line(f"{last_line}: ...")
+                            writer.write_line("")  # Blank line after method
+
+                            # For Protocol, we only want the signature stub, not the implementation
+                            # Skip all remaining lines of this method by jumping to end
+                            i = len(lines)  # This will exit the while loop
+                            break
+
+                        i += 1
+                    continue
+
+                i += 1
+
+        writer.dedent()  # Close class
+        return writer.get_code()
+
+    def _generate_endpoint_implementation(self, tag: str, method_codes: list[str], context: RenderContext) -> str:
+        """
+        Generate the endpoint client implementation class.
+
+        Args:
+            tag: The tag name for the endpoint group
+            method_codes: List of method code blocks as strings
+            context: Render context for import management
+
+        Returns:
+            Implementation class code as string
+        """
+        context.add_import("typing", "cast")
+        # Import core transport and streaming helpers
+        context.add_import(f"{context.core_package_name}.http_transport", "HttpTransport")
+        context.add_import(f"{context.core_package_name}.streaming_helpers", "iter_bytes")
+        context.add_import("typing", "Callable")
+        context.add_import("typing", "Optional")
+        writer = CodeWriter()
+        class_name = NameSanitizer.sanitize_class_name(tag) + "Client"
+        protocol_name = f"{class_name}Protocol"
+
+        # Class definition - implements Protocol
+        writer.write_line(f"class {class_name}({protocol_name}):")
+        writer.indent()
+        writer.write_line(f'"""Client for {tag} endpoints. Uses HttpTransport for all HTTP and header management."""')
+        writer.write_line("")
+
+        writer.write_line("def __init__(self, transport: HttpTransport, base_url: str) -> None:")
+        writer.indent()
+        writer.write_line("self._transport = transport")
+        writer.write_line("self.base_url: str = base_url")
+        writer.dedent()
+        writer.write_line("")
+
+        # Write methods
+        for i, method_code in enumerate(method_codes):
+            # Revert to write_block, as it handles indentation correctly
+            writer.write_block(method_code)
+
+            if i < len(method_codes) - 1:
+                writer.write_line("")  # First blank line
+                writer.write_line("")  # Second blank line (for testing separation)
+
+        writer.dedent()  # Dedent to close the class block
+        return writer.get_code()
+
+    def generate_endpoint_mock_class(self, tag: str, operations: list[IROperation], context: RenderContext) -> str:
+        """
+        Generate mock implementation class for tag-based endpoint client.
+
+        Args:
+            tag: The tag name for the endpoint group
+            operations: List of operations for this tag
+            context: Render context for import management
+
+        Returns:
+            Mock class code as string with all operation method stubs
+        """
+        from .generators.mock_generator import MockGenerator
+
+        # Import Protocol for type checking
+        context.add_import("typing", "TYPE_CHECKING")
+
+        writer = CodeWriter()
+        class_name = NameSanitizer.sanitize_class_name(tag) + "Client"
+        protocol_name = f"{class_name}Protocol"
+        mock_class_name = f"Mock{class_name}"
+
+        # TYPE_CHECKING import for Protocol
+        writer.write_line("if TYPE_CHECKING:")
+        writer.indent()
+        writer.write_line(f"from ...endpoints.{NameSanitizer.sanitize_module_name(tag)} import {protocol_name}")
+        writer.dedent()
+        writer.write_line("")
+
+        # Class header with docstring
+        writer.write_line(f"class {mock_class_name}:")
+        writer.indent()
+        writer.write_line('"""')
+        writer.write_line(f"Mock implementation of {class_name} for testing.")
+        writer.write_line("")
+        writer.write_line("Provides default implementations that raise NotImplementedError.")
+        writer.write_line("Override methods as needed in your tests.")
+        writer.write_line("")
+        writer.write_line("Example:")
+        writer.write_line(f"    class Test{class_name}({mock_class_name}):")
+        writer.write_line("        async def method_name(self, ...) -> ReturnType:")
+        writer.write_line("            return test_data")
+        writer.write_line('"""')
+        writer.write_line("")
+
+        # Generate mock methods
+        mock_generator = MockGenerator(schemas=self.schemas)
+        for i, op in enumerate(operations):
+            mock_method_code = mock_generator.generate(op, context)
+            writer.write_block(mock_method_code)
+
+            if i < len(operations) - 1:
+                writer.write_line("")  # Blank line between methods
+                writer.write_line("")  # Second blank line for consistency
+
+        writer.dedent()  # Close class
+        return writer.get_code()

pyopenapi_gen/visit/endpoint/generators/__init__.py

@@ -0,0 +1 @@
+# पैसाले सुख दिदैन।

pyopenapi_gen/visit/endpoint/generators/docstring_generator.py

@@ -0,0 +1,123 @@
+"""
+Helper class for generating the docstring for an endpoint method.
+"""
+
+from __future__ import annotations
+
+import logging
+import textwrap  # For _wrap_docstring logic
+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
+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__)
+
+
+class EndpointDocstringGenerator:
+    """Generates the Python docstring for an endpoint operation."""
+
+    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:
+        """Internal helper to wrap text for docstrings."""
+        # This was a staticmethod in EndpointMethodGenerator, can be a helper here.
+        if not text:
+            return prefix.rstrip()
+        initial_indent = prefix
+        subsequent_indent = " " * len(prefix)
+        wrapped = textwrap.wrap(text, width=width, initial_indent=initial_indent, subsequent_indent=subsequent_indent)
+        # The original had "\n    ".join(wrapped), which might be too specific if prefix changes.
+        # Let's ensure it joins with newline and respects the subsequent_indent for multi-lines.
+        if not wrapped:
+            return prefix.rstrip()
+        # For single line, no complex join needed, just the wrapped line.
+        if len(wrapped) == 1:
+            return wrapped[0]
+        # For multi-line, ensure proper joining. textwrap handles indent per line.
+        return "\n".join(wrapped)
+
+    def generate_docstring(
+        self,
+        writer: CodeWriter,
+        op: IROperation,
+        context: RenderContext,
+        primary_content_type: str | None,
+        response_strategy: ResponseStrategy,
+    ) -> None:
+        """Writes the method docstring to the provided CodeWriter."""
+        summary = op.summary or None
+        description = op.description or None
+        args: list[tuple[str, str, str] | tuple[str, str]] = []
+
+        for param in op.parameters:
+            param_type = get_param_type(param, context, self.schemas)
+            desc = param.description or ""
+            args.append((param.name, param_type, desc))
+
+        if op.request_body and primary_content_type:
+            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)"))
+            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)"))
+            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)"))
+            else:  # Fallback for other types like application/octet-stream
+                args.append(("bytes_content", "bytes", body_desc + f" ({primary_content_type})"))
+
+        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
+            resp = next((r for r in op.responses if r.status_code == code), None)
+            if resp and resp.description:
+                response_desc = resp.description.strip()
+                break
+        if not response_desc:  # Fallback to any response description if no 2xx/default found
+            for resp in op.responses:
+                if resp.description:
+                    response_desc = resp.description.strip()
+                    break
+
+        returns = (return_type, response_desc or "Response object.") if return_type and return_type != "None" else None
+
+        error_codes = [r for r in op.responses if r.status_code.isdigit() and int(r.status_code) >= 400]
+        raises = []
+        if error_codes:
+            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.'}"
+                raises.append((code_to_raise, desc))
+        else:
+            raises.append(("HTTPError", "If the server returns a non-2xx HTTP response."))
+
+        doc_block = DocumentationBlock(
+            summary=summary,
+            description=description,
+            args=args,
+            returns=returns,
+            raises=raises,
+        )
+
+        # The DocumentationWriter handles the actual formatting and wrapping.
+        # The _wrap_docstring helper is not directly used here if DocumentationWriter handles it all.
+        # However, DocumentationWriter.render_docstring itself might need indentation control.
+        # Original called writer.write_line(line) for each line of docstring.
+        docstring_str = self.doc_writer.render_docstring(
+            doc_block, indent=0
+        )  # indent=0 as CodeWriter handles method indent
+        for line in docstring_str.splitlines():
+            writer.write_line(line)

pyopenapi_gen/visit/endpoint/generators/endpoint_method_generator.py

@@ -0,0 +1,222 @@
+import logging
+import re
+from typing import Any
+
+from pyopenapi_gen import IROperation
+
+from ....context.render_context import RenderContext
+from ....core.utils import Formatter, NameSanitizer
+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
+from .overload_generator import OverloadMethodGenerator
+from .request_generator import EndpointRequestGenerator
+from .response_handler_generator import EndpointResponseHandlerGenerator
+from .signature_generator import EndpointMethodSignatureGenerator
+from .url_args_generator import EndpointUrlArgsGenerator
+
+# Get logger instance
+logger = logging.getLogger(__name__)
+
+
+class EndpointMethodGenerator:
+    """
+    Generates the Python code for a single endpoint method.
+    """
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas = schemas or {}
+        self.formatter = Formatter()
+        self.parameter_processor = EndpointParameterProcessor(self.schemas)
+        self.import_analyzer = EndpointImportAnalyzer(self.schemas)
+        self.signature_generator = EndpointMethodSignatureGenerator(self.schemas)
+        self.docstring_generator = EndpointDocstringGenerator(self.schemas)
+        self.url_args_generator = EndpointUrlArgsGenerator(self.schemas)
+        self.request_generator = EndpointRequestGenerator(self.schemas)
+        self.response_handler_generator = EndpointResponseHandlerGenerator(self.schemas)
+        self.overload_generator = OverloadMethodGenerator(self.schemas)
+
+    def generate(self, op: IROperation, context: RenderContext) -> str:
+        """
+        Generate a fully functional async endpoint method for the given operation.
+        Returns the method code as a string.
+
+        If the operation has multiple content types, generates @overload signatures
+        followed by the implementation method with runtime dispatch.
+        """
+        context.add_import(f"{context.core_package_name}.http_transport", "HttpTransport")
+        context.add_import(f"{context.core_package_name}.exceptions", "HTTPError")
+
+        # UNIFIED RESPONSE STRATEGY: Resolve once, use everywhere
+        strategy_resolver = ResponseStrategyResolver(self.schemas)
+        response_strategy = strategy_resolver.resolve(op, context)
+
+        # Pass the response strategy to import analyzer for consistent import resolution
+        self.import_analyzer.analyze_and_register_imports(op, context, response_strategy)
+
+        # Check if operation has multiple content types
+        if self.overload_generator.has_multiple_content_types(op):
+            return self._generate_overloaded_method(op, context, response_strategy)
+        else:
+            return self._generate_standard_method(op, context, response_strategy)
+
+    def _generate_standard_method(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """Generate standard method without overloads."""
+        writer = CodeWriter()
+
+        ordered_params, primary_content_type, resolved_body_type = self.parameter_processor.process_parameters(
+            op, context
+        )
+
+        # 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.
+        code_snapshot_before_body_parts = writer.get_code()
+
+        has_header_params = self.url_args_generator.generate_url_and_args(
+            writer, op, context, ordered_params, primary_content_type, resolved_body_type
+        )
+        self.request_generator.generate_request_call(writer, op, context, has_header_params, primary_content_type)
+
+        # 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()
+        # The part of the code added by the body-writing methods
+        body_part_actually_written = current_full_code[len(code_snapshot_before_body_parts) :]
+
+        body_is_effectively_empty = True
+        # Check if the written body part contains any non-comment, non-whitespace lines
+        if body_part_actually_written.strip():  # Check if non-whitespace exists at all
+            if any(
+                line.strip() and not line.strip().startswith("#") for line in body_part_actually_written.splitlines()
+            ):
+                body_is_effectively_empty = False
+
+        if body_is_effectively_empty:
+            writer.write_line("pass")
+
+        writer.dedent()  # This matches the indent() from _write_method_signature
+
+        return writer.get_code().strip()
+
+    def _generate_overloaded_method(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """Generate method with @overload signatures for multiple content types."""
+        parts = []
+
+        # Generate overload signatures
+        overload_sigs = self.overload_generator.generate_overload_signatures(op, context, response_strategy)
+        parts.extend(overload_sigs)
+
+        # Generate implementation method
+        impl_method = self._generate_implementation_method(op, context, response_strategy)
+        parts.append(impl_method)
+
+        # Join with double newlines between overloads and implementation
+        return "\n\n".join(parts)
+
+    def _generate_implementation_method(self, op: IROperation, context: RenderContext, response_strategy: Any) -> str:
+        """Generate the implementation method with runtime dispatch for multiple content types."""
+        # Type narrowing: request_body is guaranteed to exist when this method is called
+        assert (
+            op.request_body is not None
+        ), "request_body should not be None in _generate_implementation_method"  # nosec B101 - Type narrowing for mypy, validated by has_multiple_content_types
+
+        writer = CodeWriter()
+
+        # Import DataclassSerializer for automatic conversion
+        context.add_import(f"{context.core_package_name}.utils", "DataclassSerializer")
+
+        # Generate implementation signature (accepts all content-type parameters as optional)
+        impl_sig = self.overload_generator.generate_implementation_signature(op, context, response_strategy)
+        writer.write_block(impl_sig)
+
+        # Generate docstring
+        ordered_params, primary_content_type, _ = self.parameter_processor.process_parameters(op, context)
+        writer.indent()
+        writer.write_line('"""')
+        writer.write_line(f"{op.summary or op.operation_id}")
+        writer.write_line("")
+        writer.write_line("Supports multiple content types:")
+        for content_type in op.request_body.content.keys():
+            writer.write_line(f"- {content_type}")
+        writer.write_line('"""')
+
+        # Generate URL construction with sanitized path variables
+        formatted_path = re.sub(
+            r"{([^}]+)}", lambda m: f"{{{NameSanitizer.sanitize_method_name(str(m.group(1)))}}}", op.path
+        )
+        writer.write_line(f'url = f"{{self.base_url}}{formatted_path}"')
+        writer.write_line("")
+
+        # Generate runtime dispatch logic
+        writer.write_line("# Runtime dispatch based on content type")
+
+        first_content_type = True
+        for content_type in op.request_body.content.keys():
+            param_info = self.overload_generator._get_content_type_param_info(
+                content_type, op.request_body.content[content_type], context
+            )
+
+            if first_content_type:
+                writer.write_line(f"if {param_info['name']} is not None:")
+                first_content_type = False
+            else:
+                writer.write_line(f"elif {param_info['name']} is not None:")
+
+            writer.indent()
+
+            # Generate request call for this content type
+            if content_type == "application/json":
+                writer.write_line(f"json_body = DataclassSerializer.serialize({param_info['name']})")
+                writer.write_line("response = await self._transport.request(")
+                writer.indent()
+                writer.write_line(f'"{op.method.value.upper()}", url,')
+                writer.write_line("params=None,")
+                writer.write_line("json=json_body,")
+                writer.write_line("headers=None")
+                writer.dedent()
+                writer.write_line(")")
+            elif content_type == "multipart/form-data":
+                # Files dict is already in correct format for httpx - pass directly
+                writer.write_line("response = await self._transport.request(")
+                writer.indent()
+                writer.write_line(f'"{op.method.value.upper()}", url,')
+                writer.write_line("params=None,")
+                writer.write_line(f"files={param_info['name']},")
+                writer.write_line("headers=None")
+                writer.dedent()
+                writer.write_line(")")
+            else:
+                writer.write_line(f"data = DataclassSerializer.serialize({param_info['name']})")
+                writer.write_line("response = await self._transport.request(")
+                writer.indent()
+                writer.write_line(f'"{op.method.value.upper()}", url,')
+                writer.write_line("params=None,")
+                writer.write_line("data=data,")
+                writer.write_line("headers=None")
+                writer.dedent()
+                writer.write_line(")")
+
+            writer.dedent()
+
+        # Add else clause for error
+        writer.write_line("else:")
+        writer.indent()
+        writer.write_line('raise ValueError("One of the content-type parameters must be provided")')
+        writer.dedent()
+        writer.write_line("")
+
+        # Generate response handling (reuse existing generator)
+        self.response_handler_generator.generate_response_handling(writer, op, context, response_strategy)
+
+        writer.dedent()
+
+        return writer.get_code().strip()