pyopenapi-gen 0.8.3__py3-none-any.whl

pyopenapi_gen/visit/endpoint/generators/signature_generator.py

@@ -0,0 +1,88 @@
+"""
+Helper class for generating the method signature for an endpoint.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+
+from pyopenapi_gen.core.utils import NameSanitizer
+from pyopenapi_gen.core.writers.code_writer import CodeWriter
+
+# Import necessary helpers from endpoint_utils if they were used directly or indirectly
+from pyopenapi_gen.helpers.endpoint_utils import get_param_type, get_return_type_unified  # Added
+
+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: Optional[Dict[str, Any]] = 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]],
+    ) -> 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"])
+
+        return_type = get_return_type_unified(op, context, self.schemas)
+        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):
+                # Default value handling: if default is None, it should be ' = None'
+                # If default is a string, it should be ' = "default_value"'
+                # Otherwise, ' = default_value'
+                default_val = p.get("default")
+                if default_val is None and not p.get("required", False):  # Explicitly check for None for Optional types
+                    arg_str += f" = None"
+                elif default_val is not None:  # Only add if default is not None
+                    if isinstance(default_val, str):
+                        arg_str += f' = "{default_val}"'
+                    else:
+                        arg_str += f" = {default_val}"
+            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,183 @@
+"""
+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, Dict, List, Optional
+
+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: Optional[Dict[str, Any]] = 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
+
+        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}": {param_var_name}{line_end}')
+            else:
+                # Using dict unpacking for conditional parameters
+                writer.write_line(
+                    f'    **({{"{original_param_name}": {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"]
+
+        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}": {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}": {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: Optional[str],
+        resolved_body_type: Optional[str],
+    ) -> bool:
+        """Writes URL, query, and header parameters. Returns True if header params were written."""
+        # Main logic from EndpointMethodGenerator._write_url_and_args
+        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,76 @@
+"""
+Helper class for analyzing an IROperation and registering necessary imports.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, Optional  # IO for multipart type hint
+
+# Necessary helpers for type analysis
+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  # IRParameter for op.parameters type hint
+    from pyopenapi_gen.context.render_context import RenderContext
+
+logger = logging.getLogger(__name__)
+
+
+class EndpointImportAnalyzer:
+    """Analyzes an IROperation to determine and register required imports."""
+
+    def __init__(self, schemas: Optional[Dict[str, Any]] = None) -> None:
+        self.schemas: Dict[str, Any] = schemas or {}
+
+    def analyze_and_register_imports(
+        self,
+        op: IROperation,
+        context: RenderContext,
+    ) -> 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: Optional[str] = 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)
+
+        return_type = get_return_type_unified(op, context, self.schemas)
+        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, Dict, List, Optional, 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: Optional[Dict[str, Any]] = None) -> None:
+        self.schemas: Dict[str, Any] = schemas or {}
+
+    def process_parameters(
+        self, op: IROperation, context: RenderContext
+    ) -> Tuple[List[Dict[str, Any]], Optional[str], Optional[str]]:
+        """
+        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: Optional[str] = None
+        resolved_body_type: Optional[str] = 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: Optional[Dict[str, Any]] = 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,52 @@
+from pyopenapi_gen import IRSpec
+
+from ..context.render_context import RenderContext
+from ..core.writers.python_construct_renderer import PythonConstructRenderer
+
+
+class ExceptionVisitor:
+    """Visitor for rendering exception alias classes from IRSpec."""
+
+    def __init__(self) -> None:
+        self.renderer = PythonConstructRenderer()
+
+    def visit(self, spec: IRSpec, context: RenderContext) -> tuple[str, list[str]]:
+        # Register base exception imports
+        context.add_import(f"{context.core_package_name}.exceptions", "HTTPError")
+        context.add_import(f"{context.core_package_name}.exceptions", "ClientError")
+        context.add_import(f"{context.core_package_name}.exceptions", "ServerError")
+        context.add_import("httpx", "Response")
+
+        # Collect unique numeric status codes
+        codes = sorted(
+            {int(resp.status_code) for op in spec.operations for resp in op.responses if resp.status_code.isdigit()}
+        )
+
+        all_exception_code = []
+        generated_alias_names = []
+
+        # Use renderer to generate each exception class
+        for code in codes:
+            base_class = "ClientError" if code < 500 else "ServerError"
+            class_name = f"Error{code}"
+            generated_alias_names.append(class_name)
+            docstring = f"Exception alias for HTTP {code} responses."
+
+            # Define the __init__ method body
+            init_method_body = [
+                "def __init__(self, response: Response) -> None:",
+                "    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
+        final_code = "\n".join(all_exception_code)
+        return final_code, generated_alias_names

pyopenapi_gen/visit/model/alias_generator.py

@@ -0,0 +1,89 @@
+"""
+Generates Python code for type aliases from IRSchema objects.
+"""
+
+import logging
+from typing import Dict, Optional
+
+from pyopenapi_gen import IRSchema
+from pyopenapi_gen.context.render_context import RenderContext
+from pyopenapi_gen.core.utils import NameSanitizer
+from pyopenapi_gen.core.writers.python_construct_renderer import PythonConstructRenderer
+from pyopenapi_gen.helpers.type_resolution.finalizer import TypeFinalizer
+from pyopenapi_gen.types.services.type_service import UnifiedTypeService
+
+logger = logging.getLogger(__name__)
+
+
+class AliasGenerator:
+    """Generates Python code for a type alias."""
+
+    def __init__(
+        self,
+        renderer: PythonConstructRenderer,
+        all_schemas: Optional[Dict[str, IRSchema]],
+    ):
+        # Pre-condition
+        assert renderer is not None, "PythonConstructRenderer cannot be None"
+        self.renderer = renderer
+        self.all_schemas = all_schemas if all_schemas is not None else {}
+        self.type_service = UnifiedTypeService(self.all_schemas)
+
+    def generate(
+        self,
+        schema: IRSchema,
+        base_name: str,
+        context: RenderContext,
+    ) -> str:
+        """
+        Generates the Python code for a type alias.
+
+        Args:
+            schema: The IRSchema for the alias.
+            base_name: The base name for the alias (e.g., schema.name).
+            context: The render context.
+
+        Returns:
+            The generated Python code string for the type alias.
+
+        Contracts:
+            Pre-conditions:
+                - ``schema`` is not None and ``schema.name`` is not None.
+                - ``base_name`` is a non-empty string.
+                - ``context`` is not None.
+                - The schema should logically represent a type alias
+                  (e.g., not have properties if it's not an array of anonymous objects).
+            Post-conditions:
+                - Returns a non-empty string containing valid Python code for a type alias.
+                - ``TypeAlias`` is imported in the context if not already present.
+        """
+        # Pre-conditions
+        assert schema is not None, "Schema cannot be None for alias generation."
+        assert schema.name is not None, "Schema name must be present for alias generation."
+        assert base_name, "Base name cannot be empty for alias generation."
+        assert context is not None, "RenderContext cannot be None."
+
+        alias_name = NameSanitizer.sanitize_class_name(base_name)
+        target_type = self.type_service.resolve_schema_type(schema, context, required=True, resolve_underlying=True)
+        target_type = TypeFinalizer(context)._clean_type(target_type)
+
+        # logger.debug(f"AliasGenerator: Rendering alias '{alias_name}' for target type '{target_type}'.")
+
+        rendered_code = self.renderer.render_alias(
+            alias_name=alias_name,
+            target_type=target_type,
+            description=schema.description,
+            context=context,
+        )
+
+        # Post-condition
+        assert rendered_code.strip(), "Generated alias code cannot be empty."
+        # PythonConstructRenderer is responsible for adding TypeAlias import
+        # We can check if it was added to context if 'TypeAlias' is in the rendered code
+        if "TypeAlias" in rendered_code:
+            assert (
+                "typing" in context.import_collector.imports
+                and "TypeAlias" in context.import_collector.imports["typing"]
+            ), "TypeAlias import was not added to context by renderer."
+
+        return rendered_code