pyopenapi-gen 2.7.2__py3-none-any.whl

pyopenapi_gen/visit/endpoint/generators/signature_generator.py

@@ -0,0 +1,83 @@
+"""
+Helper class for generating the method signature for an endpoint.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, List
+
+from pyopenapi_gen.core.utils import NameSanitizer
+from pyopenapi_gen.core.writers.code_writer import CodeWriter
+
+# Import necessary helpers from endpoint_utils
+from pyopenapi_gen.helpers.endpoint_utils import get_param_type
+from pyopenapi_gen.types.strategies.response_strategy import ResponseStrategy
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IROperation
+    from pyopenapi_gen.context.render_context import RenderContext
+
+logger = logging.getLogger(__name__)
+
+
+class EndpointMethodSignatureGenerator:
+    """Generates the Python method signature for an endpoint operation."""
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
+
+    def generate_signature(
+        self,
+        writer: CodeWriter,
+        op: IROperation,
+        context: RenderContext,
+        ordered_params: List[dict[str, Any]],
+        strategy: ResponseStrategy,
+    ) -> None:
+        """Writes the method signature to the provided CodeWriter."""
+        # Logic from EndpointMethodGenerator._write_method_signature
+        for p_info in ordered_params:  # Renamed p to p_info to avoid conflict if IRParameter is named p
+            context.add_typing_imports_for_type(p_info["type"])
+
+        # Use strategy return type instead of computing it again
+        return_type = strategy.return_type
+        context.add_typing_imports_for_type(return_type)
+
+        # Check if AsyncIterator is in return_type or any parameter type
+        # Note: op.parameters contains IRParameter objects, not the dicts in ordered_params directly
+        # We need to re-calculate param_type for op.parameters if we want to be fully independent here
+        # For now, assuming ordered_params covers all type information needed for imports or that context handles it.
+        # If direct access to op.parameters schema is needed, get_param_type might be called again here.
+        # For simplicity, this check will just look at the final return_type string for now.
+        # A more robust solution might involve a richer parameter object passed to this generator.
+        if "AsyncIterator" in return_type:
+            context.add_plain_import("collections.abc")
+        # A more complete check for AsyncIterator in parameters:
+        for param_spec in op.parameters:  # Iterate over IROperation's parameters
+            # This get_param_type call might be redundant if ordered_params already has fully resolved types
+            # and context.add_typing_imports_for_type(p_info["type"]) handled it.
+            # However, to be safe and explicit about where AsyncIterator might come from:
+            param_py_type = get_param_type(param_spec, context, self.schemas)
+            if "AsyncIterator" in param_py_type:
+                context.add_plain_import("collections.abc")
+                break  # Found one, no need to check further
+
+        args = ["self"]
+        for p_orig in ordered_params:
+            p = p_orig.copy()  # Work with a copy
+            arg_str = f"{NameSanitizer.sanitize_method_name(p['name'])}: {p['type']}"  # Ensure param name is sanitized
+            if not p.get("required", False):
+                # For optional parameters, always default to None to avoid type mismatches
+                # (e.g., enum-typed params with string defaults)
+                arg_str += " = None"
+            args.append(arg_str)
+
+        actual_return_type = return_type
+        writer.write_function_signature(
+            NameSanitizer.sanitize_method_name(op.operation_id),
+            args,
+            return_type=actual_return_type,
+            async_=True,
+        )
+        writer.indent()  # Keep the indent call as the original method did

pyopenapi_gen/visit/endpoint/generators/url_args_generator.py

@@ -0,0 +1,207 @@
+"""
+Helper class for generating URL, query parameters, and header parameters for an endpoint method.
+"""
+
+from __future__ import annotations
+
+import logging
+import re  # For _build_url_with_path_vars
+from typing import TYPE_CHECKING, Any, List
+
+from pyopenapi_gen.core.utils import NameSanitizer
+from pyopenapi_gen.core.writers.code_writer import CodeWriter
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IROperation  # IRParameter might be needed for op.parameters access
+    from pyopenapi_gen.context.render_context import RenderContext
+
+logger = logging.getLogger(__name__)
+
+
+class EndpointUrlArgsGenerator:
+    """Generates URL, query, and header parameters for an endpoint method."""
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
+
+    def _build_url_with_path_vars(self, path: str) -> str:
+        """Builds the f-string for URL construction, substituting path variables."""
+        # Ensure m.group(1) is treated as a string for NameSanitizer
+        # Build the URL f-string by substituting path variables
+        formatted_path = re.sub(
+            r"{([^}]+)}", lambda m: f"{{{NameSanitizer.sanitize_method_name(str(m.group(1)))}}}", path
+        )
+        return f'f"{{self.base_url}}{formatted_path}"'
+
+    def _write_query_params(
+        self, writer: CodeWriter, op: IROperation, ordered_params: List[dict[str, Any]], context: RenderContext
+    ) -> None:
+        """Writes query parameter dictionary construction."""
+        # Logic from EndpointMethodGenerator._write_query_params
+        query_params_to_write = [p for p in ordered_params if p.get("param_in") == "query"]
+        if not query_params_to_write:
+            # writer.write_line("# No query parameters to write") # Optional: for clarity during debugging
+            return
+
+        # Import DataclassSerializer since we use it for parameter serialization
+        context.add_import(f"{context.core_package_name}.utils", "DataclassSerializer")
+
+        for i, p in enumerate(query_params_to_write):
+            param_var_name = NameSanitizer.sanitize_method_name(p["name"])  # Ensure name is sanitized
+            original_param_name = p["original_name"]
+            line_end = ","  # Always add comma, let formatter handle final one if needed
+
+            if p.get("required", False):
+                writer.write_line(
+                    f'    "{original_param_name}": DataclassSerializer.serialize({param_var_name}){line_end}'
+                )
+            else:
+                # Using dict unpacking for conditional parameters
+                writer.write_line(
+                    f'    **({{"{original_param_name}": DataclassSerializer.serialize({param_var_name})}} '
+                    f"if {param_var_name} is not None else {{}}){line_end}"
+                )
+
+    def _write_header_params(
+        self, writer: CodeWriter, op: IROperation, ordered_params: List[dict[str, Any]], context: RenderContext
+    ) -> None:
+        """Writes header parameter dictionary construction."""
+        # Logic from EndpointMethodGenerator._write_header_params
+        # Iterate through ordered_params to find header params, op.parameters may not be directly useful here
+        # if ordered_params is the sole source of truth for method params.
+        header_params_to_write = [p for p in ordered_params if p.get("param_in") == "header"]
+
+        # Import DataclassSerializer since we use it for parameter serialization
+        if header_params_to_write:
+            context.add_import(f"{context.core_package_name}.utils", "DataclassSerializer")
+
+        for p_info in header_params_to_write:
+            param_var_name = NameSanitizer.sanitize_method_name(
+                p_info["name"]
+            )  # Sanitized name used in method signature
+            original_header_name = p_info["original_name"]  # Actual header name for the request
+            line_end = ","
+
+            if p_info.get("required", False):
+                writer.write_line(
+                    f'    "{original_header_name}": DataclassSerializer.serialize({param_var_name}){line_end}'
+                )
+            else:
+                # Conditional inclusion for optional headers
+                # This assumes that if an optional header parameter is None, it should not be sent.
+                # If specific behavior (e.g. empty string) is needed for None, logic would adjust.
+                writer.write_line(
+                    f'    **({{"{original_header_name}": DataclassSerializer.serialize({param_var_name})}} '
+                    f"if {param_var_name} is not None else {{}}){line_end}"
+                )
+
+    def generate_url_and_args(
+        self,
+        writer: CodeWriter,
+        op: IROperation,
+        context: RenderContext,
+        ordered_params: List[dict[str, Any]],
+        primary_content_type: str | None,
+        resolved_body_type: str | None,
+    ) -> bool:
+        """Writes URL, query, and header parameters. Returns True if header params were written."""
+        # Main logic from EndpointMethodGenerator._write_url_and_args
+
+        # Serialize path parameters before URL construction
+        # This ensures enums, dates, and other complex types are converted to strings
+        # before f-string interpolation in the URL
+        path_params = [p for p in ordered_params if p.get("param_in") == "path"]
+        if path_params:
+            # Import DataclassSerializer since we use it for parameter serialization
+            context.add_import(f"{context.core_package_name}.utils", "DataclassSerializer")
+            for p in path_params:
+                param_var_name = NameSanitizer.sanitize_method_name(p["name"])
+                writer.write_line(f"{param_var_name} = DataclassSerializer.serialize({param_var_name})")
+            writer.write_line("")  # Blank line after path param serialization
+
+        url_expr = self._build_url_with_path_vars(op.path)
+        writer.write_line(f"url = {url_expr}")
+        writer.write_line("")  # Add a blank line for readability
+
+        # Query Parameters
+        # Check if any parameter in ordered_params is a query param, not just op.parameters
+        has_spec_query_params = any(p.get("param_in") == "query" for p in ordered_params)
+        if has_spec_query_params:
+            context.add_import("typing", "Any")  # For dict[str, Any]
+            context.add_import("typing", "Dict")  # For dict[str, Any]
+            writer.write_line("params: dict[str, Any] = {")
+            # writer.indent() # Indentation should be handled by CodeWriter when writing lines
+            self._write_query_params(writer, op, ordered_params, context)
+            # writer.dedent()
+            writer.write_line("}")
+            writer.write_line("")  # Add a blank line
+
+        # Header Parameters
+        has_header_params = any(p.get("param_in") == "header" for p in ordered_params)
+        if has_header_params:
+            context.add_import("typing", "Any")  # For dict[str, Any]
+            context.add_import("typing", "Dict")  # For dict[str, Any]
+            writer.write_line("headers: dict[str, Any] = {")
+            # writer.indent()
+            self._write_header_params(writer, op, ordered_params, context)
+            # writer.dedent()
+            writer.write_line("}")
+            writer.write_line("")  # Add a blank line
+
+        # Request Body related local variables (json_body, files_data, etc.)
+        # This part was in _write_url_and_args in the original, it sets up variables used by _write_request
+        if op.request_body:
+            # Import DataclassSerializer for automatic conversion
+            context.add_import(f"{context.core_package_name}.utils", "DataclassSerializer")
+
+            if primary_content_type == "application/json":
+                body_param_detail = next((p for p in ordered_params if p["name"] == "body"), None)
+                if body_param_detail:
+                    actual_body_type_from_signature = body_param_detail["type"]
+                    context.add_typing_imports_for_type(actual_body_type_from_signature)
+                    writer.write_line(
+                        f"json_body: {actual_body_type_from_signature} = DataclassSerializer.serialize(body)"
+                    )
+                else:
+                    logger.warning(
+                        f"Operation {op.operation_id}: 'body' parameter not found in "
+                        f"ordered_params for JSON. Defaulting to Any."
+                    )
+                    context.add_import("typing", "Any")
+                    writer.write_line("json_body: Any = DataclassSerializer.serialize(body)  # param not found")
+            elif primary_content_type == "multipart/form-data":
+                files_param_details = next((p for p in ordered_params if p["name"] == "files"), None)
+                if files_param_details:
+                    actual_files_param_type = files_param_details["type"]
+                    context.add_typing_imports_for_type(actual_files_param_type)
+                    writer.write_line(f"files_data: {actual_files_param_type} = DataclassSerializer.serialize(files)")
+                else:
+                    logger.warning(
+                        f"Operation {op.operation_id}: Could not find 'files' parameter details "
+                        f"for multipart/form-data. Defaulting type."
+                    )
+                    context.add_import("typing", "Dict")
+                    context.add_import("typing", "IO")  # For IO[Any]
+                    context.add_import("typing", "Any")
+                    writer.write_line(
+                        "files_data: dict[str, IO[Any]] = DataclassSerializer.serialize(files)  # type failed"
+                    )
+            elif primary_content_type == "application/x-www-form-urlencoded":
+                # form_data is the expected parameter name from EndpointParameterProcessor
+                # resolved_body_type should be dict[str, Any]
+                if resolved_body_type:
+                    writer.write_line(
+                        f"form_data_body: {resolved_body_type} = DataclassSerializer.serialize(form_data)"
+                    )
+                else:  # Should not happen if EndpointParameterProcessor sets it
+                    context.add_import("typing", "Dict")
+                    context.add_import("typing", "Any")
+                    writer.write_line(
+                        "form_data_body: dict[str, Any] = DataclassSerializer.serialize(form_data)  # Fallback type"
+                    )
+            elif resolved_body_type == "bytes":  # e.g. application/octet-stream
+                # bytes_content is the expected parameter name from EndpointParameterProcessor
+                writer.write_line(f"bytes_body: bytes = bytes_content")
+            writer.write_line("")  # Add a blank line after body var setup
+
+        return has_header_params

pyopenapi_gen/visit/endpoint/processors/__init__.py

@@ -0,0 +1 @@
+# Happiness is not for sale.

pyopenapi_gen/visit/endpoint/processors/import_analyzer.py

@@ -0,0 +1,78 @@
+"""
+Helper class for analyzing an IROperation and registering necessary imports.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any  # IO for multipart type hint
+
+# Necessary helpers for type analysis
+from pyopenapi_gen.helpers.endpoint_utils import (
+    get_param_type,
+    get_request_body_type,
+)
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IROperation  # IRParameter for op.parameters type hint
+    from pyopenapi_gen.context.render_context import RenderContext
+    from pyopenapi_gen.types.strategies.response_strategy import ResponseStrategy
+
+logger = logging.getLogger(__name__)
+
+
+class EndpointImportAnalyzer:
+    """Analyzes an IROperation to determine and register required imports."""
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
+
+    def analyze_and_register_imports(
+        self,
+        op: IROperation,
+        context: RenderContext,
+        response_strategy: ResponseStrategy,
+    ) -> None:
+        """Analyzes the operation and registers imports with the RenderContext."""
+        for param in op.parameters:  # op.parameters are IRParameter objects
+            py_type = get_param_type(param, context, self.schemas)
+            context.add_typing_imports_for_type(py_type)
+
+        if op.request_body:
+            content_types = op.request_body.content.keys()
+            body_param_type: str | None = None
+            if "multipart/form-data" in content_types:
+                # Type for multipart is dict[str, IO[Any]] which requires IO and Any
+                context.add_import("typing", "Dict")
+                context.add_import("typing", "IO")
+                context.add_import("typing", "Any")
+                # The actual type string "dict[str, IO[Any]]" will be handled by add_typing_imports_for_type if passed
+                # but ensuring components are imported is key.
+                body_param_type = "dict[str, IO[Any]]"
+            elif "application/json" in content_types:
+                body_param_type = get_request_body_type(op.request_body, context, self.schemas)
+            elif "application/x-www-form-urlencoded" in content_types:
+                context.add_import("typing", "Dict")
+                context.add_import("typing", "Any")
+                body_param_type = "dict[str, Any]"
+            elif content_types:  # Fallback for other types like application/octet-stream
+                body_param_type = "bytes"
+
+            if body_param_type:
+                context.add_typing_imports_for_type(body_param_type)
+
+        # Use the response strategy's return type for import analysis
+        return_type = response_strategy.return_type
+        context.add_typing_imports_for_type(return_type)
+
+        # Check for AsyncIterator in return type or parameter types
+        async_iterator_found = "AsyncIterator" in return_type
+        if not async_iterator_found:
+            for param_spec in op.parameters:  # Iterate over IROperation's parameters
+                param_py_type = get_param_type(param_spec, context, self.schemas)  # Re-check type for safety
+                if "AsyncIterator" in param_py_type:
+                    async_iterator_found = True
+                    break
+
+        if async_iterator_found:
+            context.add_plain_import("collections.abc")

pyopenapi_gen/visit/endpoint/processors/parameter_processor.py

@@ -0,0 +1,171 @@
+"""
+Helper class for processing parameters for an endpoint method.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, List, Tuple
+
+from pyopenapi_gen.core.utils import NameSanitizer
+from pyopenapi_gen.helpers.endpoint_utils import get_param_type, get_request_body_type
+from pyopenapi_gen.helpers.url_utils import extract_url_variables
+
+if TYPE_CHECKING:
+    from pyopenapi_gen import IROperation
+    from pyopenapi_gen.context.render_context import RenderContext
+
+logger = logging.getLogger(__name__)
+
+
+class EndpointParameterProcessor:
+    """
+    Processes IROperation parameters and request body to prepare a list of
+    method parameters for the endpoint signature and further processing.
+    """
+
+    def __init__(self, schemas: dict[str, Any] | None = None) -> None:
+        self.schemas: dict[str, Any] = schemas or {}
+
+    def process_parameters(
+        self, op: IROperation, context: RenderContext
+    ) -> Tuple[List[dict[str, Any]], str | None, str | None]:
+        """
+        Prepares and orders parameters for an endpoint method, including path,
+        query, header, and request body parameters.
+
+        Returns:
+            A tuple containing:
+            - ordered_params: List of parameter dictionaries for method signature.
+            - primary_content_type: The dominant content type for the request body.
+            - resolved_body_type: The Python type hint for the request body.
+        """
+        ordered_params: List[dict[str, Any]] = []
+        param_details_map: dict[str, dict[str, Any]] = {}
+
+        for param in op.parameters:
+            param_name_sanitized = NameSanitizer.sanitize_method_name(param.name)
+            param_info = {
+                "name": param_name_sanitized,
+                "type": get_param_type(param, context, self.schemas),
+                "required": param.required,
+                "default": param.schema.default if param.schema else None,
+                "param_in": param.param_in,
+                "original_name": param.name,
+            }
+            ordered_params.append(param_info)
+            param_details_map[param_name_sanitized] = param_info
+
+        primary_content_type: str | None = None
+        resolved_body_type: str | None = None
+
+        if op.request_body:
+            content_types = op.request_body.content.keys()
+            body_param_name = "body"  # Default name
+            context.add_import("typing", "Any")  # General fallback
+            body_specific_param_info: dict[str, Any] | None = None
+
+            if "multipart/form-data" in content_types:
+                primary_content_type = "multipart/form-data"
+                body_param_name = "files"
+                context.add_import("typing", "Dict")
+                context.add_import("typing", "IO")
+                resolved_body_type = "dict[str, IO[Any]]"
+                body_specific_param_info = {
+                    "name": body_param_name,
+                    "type": resolved_body_type,
+                    "required": op.request_body.required,
+                    "default": None,
+                    "param_in": "body",
+                    "original_name": body_param_name,
+                }
+            elif "application/json" in content_types:
+                primary_content_type = "application/json"
+                body_param_name = "body"
+                resolved_body_type = get_request_body_type(op.request_body, context, self.schemas)
+                body_specific_param_info = {
+                    "name": body_param_name,
+                    "type": resolved_body_type,
+                    "required": op.request_body.required,
+                    "default": None,
+                    "param_in": "body",
+                    "original_name": body_param_name,
+                }
+            elif "application/x-www-form-urlencoded" in content_types:
+                primary_content_type = "application/x-www-form-urlencoded"
+                body_param_name = "form_data"
+                context.add_import("typing", "Dict")
+                resolved_body_type = "dict[str, Any]"
+                body_specific_param_info = {
+                    "name": body_param_name,
+                    "type": resolved_body_type,
+                    "required": op.request_body.required,
+                    "default": None,
+                    "param_in": "body",
+                    "original_name": body_param_name,
+                }
+            elif content_types:  # Fallback for other content types
+                primary_content_type = list(content_types)[0]
+                body_param_name = "bytes_content"  # e.g. for application/octet-stream
+                resolved_body_type = "bytes"
+                body_specific_param_info = {
+                    "name": body_param_name,
+                    "type": resolved_body_type,
+                    "required": op.request_body.required,
+                    "default": None,
+                    "param_in": "body",
+                    "original_name": body_param_name,
+                }
+
+            if body_specific_param_info:
+                if body_specific_param_info["name"] not in param_details_map:
+                    ordered_params.append(body_specific_param_info)
+                    param_details_map[body_specific_param_info["name"]] = body_specific_param_info
+                else:
+                    logger.warning(
+                        f"Request body parameter name '{body_specific_param_info['name']}' "
+                        f"for operation '{op.operation_id}'"
+                        f"collides with an existing path/query/header parameter. Check OpenAPI spec."
+                    )
+
+        final_ordered_params = self._ensure_path_variables_as_params(op, ordered_params, param_details_map)
+
+        # Sort parameters: required first, then optional.
+        # We use a stable sort by negating 'required' (True becomes -1, False becomes 0).
+        # Parameters with the same required status maintain their relative order.
+        final_ordered_params.sort(key=lambda p: not p["required"])
+
+        return final_ordered_params, primary_content_type, resolved_body_type
+
+    def _ensure_path_variables_as_params(
+        self, op: IROperation, current_params: List[dict[str, Any]], param_details_map: dict[str, dict[str, Any]]
+    ) -> List[dict[str, Any]]:
+        """
+        Ensures that all variables in the URL path are present in the list of parameters.
+        If a path variable is not already defined as a parameter, it's added as a required string type.
+        This also updates the param_details_map.
+        """
+        url_vars = extract_url_variables(op.path)
+
+        # Make a copy to modify if necessary
+        updated_params = list(current_params)
+
+        for var in url_vars:
+            sanitized_var_name = NameSanitizer.sanitize_method_name(var)
+            if sanitized_var_name not in param_details_map:
+                path_var_param_info = {
+                    "name": sanitized_var_name,
+                    "type": "str",  # Path variables are typically strings
+                    "required": True,  # Path variables are always required
+                    "default": None,
+                    "param_in": "path",
+                    "original_name": var,
+                }
+                updated_params.append(path_var_param_info)
+                param_details_map[sanitized_var_name] = path_var_param_info
+                # logger.debug(
+                #     f"Added missing path variable '{sanitized_var_name}' "
+                #     f"to parameters for operation '{op.operation_id}'."
+                # )
+
+        return updated_params

pyopenapi_gen/visit/exception_visitor.py

@@ -0,0 +1,90 @@
+from pyopenapi_gen import IRSpec
+
+from ..context.render_context import RenderContext
+from ..core.http_status_codes import (
+    get_exception_class_name,
+    get_status_name,
+    is_client_error,
+    is_error_code,
+    is_server_error,
+)
+from ..core.writers.python_construct_renderer import PythonConstructRenderer
+
+
+class ExceptionVisitor:
+    """Visitor for rendering exception alias classes from IRSpec.
+
+    This visitor generates exception classes only for error status codes (4xx and 5xx).
+    Success codes (2xx) are intentionally excluded as they represent successful responses.
+    """
+
+    def __init__(self) -> None:
+        self.renderer = PythonConstructRenderer()
+
+    def visit(self, spec: IRSpec, context: RenderContext) -> tuple[str, list[str], list[int]]:
+        """Generate exception classes from IRSpec.
+
+        Args:
+            spec: The IRSpec containing operations and responses
+            context: Render context for imports and code generation
+
+        Returns:
+            Tuple of (generated_code, exception_class_names, status_codes_list)
+        """
+        # Register base exception imports (only the ones we actually use)
+        # Note: HTTPError is not used in exception_aliases.py, so we don't import it
+        context.add_import("httpx", "Response")  # Third-party import first (Ruff I001)
+        context.add_import(f"{context.core_package_name}.exceptions", "ClientError")
+        context.add_import(f"{context.core_package_name}.exceptions", "ServerError")
+
+        # Collect unique numeric error status codes (4xx and 5xx only)
+        all_codes = {
+            int(resp.status_code) for op in spec.operations for resp in op.responses if resp.status_code.isdigit()
+        }
+        error_codes = sorted([code for code in all_codes if is_error_code(code)])
+
+        all_exception_code = []
+        generated_alias_names = []
+
+        # Use renderer to generate each exception class
+        for code in error_codes:
+            # Determine base class using helper functions
+            if is_client_error(code):
+                base_class = "ClientError"
+            elif is_server_error(code):
+                base_class = "ServerError"
+            else:
+                # Should not happen since we filtered to 4xx/5xx, but be defensive
+                continue
+
+            # Get human-readable exception class name (e.g., NotFoundError instead of Error404)
+            class_name = get_exception_class_name(code)
+            generated_alias_names.append(class_name)
+
+            # Get human-readable status name for documentation
+            status_name = get_status_name(code)
+            docstring = f"HTTP {code} {status_name}.\n\nRaised when the server responds with a {code} status code."
+
+            # Define the __init__ method body
+            init_method_body = [
+                "def __init__(self, response: Response) -> None:",
+                f'    """Initialise {class_name} with the HTTP response.',
+                "",  # Empty line without trailing whitespace (Ruff W293)
+                "    Args:",
+                "        response: The httpx Response object that triggered this exception",
+                '    """',
+                "    super().__init__(status_code=response.status_code, message=response.text, response=response)",
+            ]
+
+            exception_code = self.renderer.render_class(
+                class_name=class_name,
+                base_classes=[base_class],
+                docstring=docstring,
+                body_lines=init_method_body,
+                context=context,
+            )
+            all_exception_code.append(exception_code)
+
+        # Join the generated class strings with 2 blank lines between classes (PEP 8 / Ruff E302)
+        final_code = "\n\n\n".join(all_exception_code)
+        return final_code, generated_alias_names, error_codes