pyopenapi-gen 0.8.3__py3-none-any.whl

pyopenapi_gen/visit/client_visitor.py

@@ -0,0 +1,228 @@
+import logging  # Added for logging
+import re
+import textwrap
+from typing import TYPE_CHECKING, cast
+
+from pyopenapi_gen import IRSpec
+
+from ..context.render_context import RenderContext
+from ..core.utils import NameSanitizer
+from ..core.writers.code_writer import CodeWriter
+from ..core.writers.documentation_writer import DocumentationBlock, DocumentationWriter
+
+if TYPE_CHECKING:
+    # To prevent circular imports if any type from core itself is needed for hints
+    pass
+
+logger = logging.getLogger(__name__)  # Added for logging
+
+
+class ClientVisitor:
+    """Visitor for rendering the Python API client from IRSpec."""
+
+    def __init__(self) -> None:
+        pass
+
+    def visit(self, spec: IRSpec, context: RenderContext) -> str:
+        tag_candidates: dict[str, list[str]] = {}
+        for op in spec.operations:
+            # Use DEFAULT_TAG consistent with EndpointsEmitter
+            tags = op.tags or ["default"]  # Use literal "default" here
+            # Loop through the determined tags (original or default)
+            for tag in tags:
+                key = NameSanitizer.normalize_tag_key(tag)
+                if key not in tag_candidates:
+                    tag_candidates[key] = []
+                tag_candidates[key].append(tag)
+            # Ensure the old logic is removed (idempotent if already gone)
+            # if op.tags:
+            #     ...
+            # else:
+            #     ...
+
+        def tag_score(t: str) -> tuple[bool, int, int, str]:
+            is_pascal = bool(re.search(r"[a-z][A-Z]", t)) or bool(re.search(r"[A-Z]{2,}", t))
+            words = re.findall(r"[A-Z]?[a-z]+|[A-Z]+(?![a-z])|[0-9]+", t)
+            words += re.split(r"[_-]+", t)
+            word_count = len([w for w in words if w])
+            upper = sum(1 for c in t if c.isupper())
+            return (is_pascal, word_count, upper, t)
+
+        tag_map = {}
+        for key, candidates in tag_candidates.items():
+            best = max(candidates, key=tag_score)
+            tag_map[key] = best
+        tag_tuples = [
+            (
+                tag_map[key],
+                NameSanitizer.sanitize_class_name(tag_map[key]) + "Client",
+                NameSanitizer.sanitize_module_name(tag_map[key]),
+            )
+            for key in sorted(tag_map)
+        ]
+        writer = CodeWriter()
+        # Register all endpoint client imports using relative imports (endpoints are within the same package)
+        for _, class_name, module_name in tag_tuples:
+            # Use relative imports for endpoints since they're part of the same generated package
+            context.import_collector.add_relative_import(f".endpoints.{module_name}", class_name)
+
+        # Register core/config/typing imports for class signature
+        # Use LOGICAL import path for core components
+
+        # Use the core_package name from the context to form the base of the import path
+        # RenderContext.add_import will handle making it relative correctly based on the current file.
+        context.add_import(f"{context.core_package_name}.http_transport", "HttpTransport")
+        context.add_import(f"{context.core_package_name}.http_transport", "HttpxTransport")
+        context.add_import(f"{context.core_package_name}.config", "ClientConfig")
+        # If security schemes are present and an auth plugin like ApiKeyAuth is used by the client itself,
+        # it would also be registered here using context.core_package.
+        # 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("Any")
+        context.add_typing_imports_for_type("Dict")
+        # Class definition
+        writer.write_line("class APIClient:")
+        writer.indent()
+        # Build docstring for APIClient
+        docstring_lines = []
+        # Add API title and version
+        docstring_lines.append(f"{spec.title} (version {spec.version})")
+        # Add API description if present
+        if getattr(spec, "description", None):
+            desc = spec.description
+            if desc is not None:
+                # Remove triple quotes, escape backslashes, and dedent
+                desc_clean = desc.replace('"""', "'").replace("'''", "'").replace("\\", "\\\\").strip()
+                desc_clean = textwrap.dedent(desc_clean)
+                docstring_lines.append("")
+                docstring_lines.append(desc_clean)
+        # Add a blank line before the generated summary/args
+        docstring_lines.append("")
+        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)."),
+        ]
+        for tag, class_name, module_name in tag_tuples:
+            args.append((module_name, class_name, f"Client for '{tag}' endpoints."))
+        doc_block = DocumentationBlock(
+            summary=summary,
+            args=cast(list[tuple[str, str, str] | tuple[str, str]], args),
+        )
+        docstring = DocumentationWriter(width=88).render_docstring(doc_block, indent=0)
+        docstring_lines.extend([line for line in docstring.splitlines()])
+        # Write only one docstring, no extra triple quotes after
+        writer.write_line('"""')  # At class indent (1)
+        writer.dedent()  # Go to indent 0 for docstring content
+        for line in docstring_lines:
+            writer.write_line(line.rstrip('"'))
+        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.indent()
+        writer.write_line("self.config = config")
+        writer.write_line(
+            "self.transport = transport if transport is not None else "
+            "HttpxTransport(str(config.base_url), config.timeout)"
+        )
+        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")
+        writer.dedent()
+        writer.write_line("")
+        # @property for each tag client
+        for tag, class_name, module_name in tag_tuples:
+            writer.write_line(f"@property")
+            # Use context.add_import here too
+            current_gen_pkg_name_prop = context.get_current_package_name_for_generated_code()
+            if not current_gen_pkg_name_prop:
+                logger.error(
+                    f"[ClientVisitor Property] Could not determine generated package name from context. "
+                    f"Cannot form fully qualified import for endpoints.{module_name}.{class_name}"
+                )
+                # Fallback or raise error
+                context.add_import(f"endpoints.{module_name}", class_name)
+            else:
+                logical_module_for_add_import_prop = f"{current_gen_pkg_name_prop}.endpoints.{module_name}"
+                context.add_import(logical_module_for_add_import_prop, class_name)
+
+            writer.write_line(f"def {module_name}(self) -> {class_name}:")
+            writer.indent()
+            writer.write_line(f'"""Client for \'{tag}\' endpoints."""')
+            writer.write_line(f"if self._{module_name} is None:")
+            writer.indent()
+            writer.write_line(f"self._{module_name} = {class_name}(self.transport, self._base_url)")
+            writer.dedent()
+            writer.write_line(f"return self._{module_name}")
+            writer.dedent()
+            writer.write_line("")
+        # request method
+        context.add_typing_imports_for_type("Any")
+        writer.write_line("async def request(self, method: str, url: str, **kwargs: Any) -> Any:")
+        writer.indent()
+        writer.write_line('"""Send an HTTP request via the transport."""')
+        writer.write_line("return await self.transport.request(method, url, **kwargs)")
+        writer.dedent()
+        writer.write_line("")
+        # close method
+        context.add_typing_imports_for_type("None")
+        writer.write_line("async def close(self) -> None:")
+        writer.indent()
+        writer.write_line('"""Close the underlying transport if supported."""')
+        writer.write_line("if hasattr(self.transport, 'close'):")
+        writer.indent()
+        writer.write_line("await self.transport.close()")
+        writer.dedent()
+        writer.write_line("else:")
+        writer.indent()
+        writer.write_line("pass  # Or log a warning if close is expected but not found")
+        writer.dedent()
+        writer.dedent()
+        writer.write_line("")
+        # __aenter__ for async context management (dedented)
+        writer.write_line("async def __aenter__(self) -> 'APIClient':")
+        writer.indent()
+        writer.write_line('"""Enter the async context manager. Returns self."""')
+        writer.write_line("if hasattr(self.transport, '__aenter__'):")
+        writer.indent()
+        writer.write_line("await self.transport.__aenter__()")
+        writer.dedent()
+        writer.write_line("return self")
+        writer.dedent()
+        writer.write_line("")
+        # __aexit__ for async context management (dedented)
+        context.add_typing_imports_for_type("type[BaseException] | None")
+        context.add_typing_imports_for_type("BaseException | None")
+        context.add_typing_imports_for_type("object | None")
+        writer.write_line(
+            "async def __aexit__(self, exc_type: type[BaseException] | None, "
+            "exc_val: BaseException | None, exc_tb: object | None) -> None:"
+        )
+        writer.indent()
+        writer.write_line('"""Exit the async context manager, ensuring transport is closed."""')
+        # Close internal transport if it supports __aexit__
+        writer.write_line("if hasattr(self.transport, '__aexit__'):")
+        writer.indent()
+        writer.write_line("await self.transport.__aexit__(exc_type, exc_val, exc_tb)")
+        writer.dedent()
+        writer.write_line("else:")  # Fallback if transport doesn't have __aexit__ but has close()
+        writer.indent()
+        writer.write_line("await self.close()")
+        writer.dedent()
+        writer.dedent()
+        writer.write_line("")
+
+        # Ensure crucial core imports are present before final rendering
+        # This is a fallback / re-emphasis due to potential issues with ImportCollector
+        context.add_import(f"{context.core_package_name}.http_transport", "HttpTransport")
+        context.add_import(f"{context.core_package_name}.http_transport", "HttpxTransport")
+        context.add_import(f"{context.core_package_name}.config", "ClientConfig")
+
+        return writer.get_code()

pyopenapi_gen/visit/docs_visitor.py

@@ -0,0 +1,38 @@
+from pyopenapi_gen import IRSpec
+
+from ..context.render_context import RenderContext
+from ..core.utils import NameSanitizer
+from ..core.writers.code_writer import CodeWriter
+
+
+class DocsVisitor:
+    """Visitor for rendering markdown documentation from IRSpec."""
+
+    def visit(self, spec: IRSpec, context: RenderContext) -> dict[str, str]:
+        # List tags
+        tags = sorted({t for op in spec.operations for t in op.tags})
+        # Generate index.md with sanitized links
+        writer = CodeWriter()
+        writer.write_line("# API Documentation\n")
+        writer.write_line("Generated documentation for the API.\n")
+        writer.write_line("## Tags")
+        for tag in tags:
+            writer.write_line(f"- [{tag}]({NameSanitizer.sanitize_module_name(tag)}.md)")
+        index_content = writer.get_code()
+        result = {"index.md": index_content}
+        # Generate docs per tag
+        for tag in tags:
+            ops = [op for op in spec.operations if tag in op.tags]
+            tag_writer = CodeWriter()
+            tag_writer.write_line(f"# {tag.capitalize()} Operations\n")
+            for op in ops:
+                tag_writer.write_line(f"### {op.operation_id}\n")
+                tag_writer.write_line(f"**Method:** `{op.method.value}`  ")
+                tag_writer.write_line(f"**Path:** `{op.path}`  \n")
+                desc = op.description or ""
+                if desc:
+                    tag_writer.write_line(desc)
+                tag_writer.write_line("")
+            filename = NameSanitizer.sanitize_module_name(tag) + ".md"
+            result[filename] = tag_writer.get_code()
+        return result

pyopenapi_gen/visit/endpoint/__init__.py

@@ -0,0 +1 @@
+# This directory will contain helper classes for EndpointMethodGenerator

pyopenapi_gen/visit/endpoint/endpoint_visitor.py

@@ -0,0 +1,103 @@
+import logging
+from typing import Any
+
+from pyopenapi_gen import IROperation
+from pyopenapi_gen.helpers.endpoint_utils import (
+    get_return_type_unified,
+)
+
+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,
+    ) -> 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.
+        """
+        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"
+        writer.write_line(f"class {class_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 _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/__init__.py

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

pyopenapi_gen/visit/endpoint/generators/docstring_generator.py

@@ -0,0 +1,121 @@
+"""
+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, 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
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IROperation
+    from pyopenapi_gen.context.render_context import RenderContext
+
+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 {}
+        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: Optional[str],
+    ) -> 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 = get_return_type_unified(op, context, self.schemas)
+        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,87 @@
+import logging
+from typing import Any
+
+from pyopenapi_gen import IROperation
+
+from ....context.render_context import RenderContext
+from ....core.utils import Formatter
+from ....core.writers.code_writer import CodeWriter
+from ..processors.import_analyzer import EndpointImportAnalyzer
+from ..processors.parameter_processor import EndpointParameterProcessor
+from .docstring_generator import EndpointDocstringGenerator
+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)
+
+    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.
+        """
+        writer = CodeWriter()
+        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.
+
+        self.import_analyzer.analyze_and_register_imports(op, context)
+
+        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)
+
+        # 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
+        self.response_handler_generator.generate_response_handling(writer, op, context)
+
+        # 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()