@sdk-it/cli 0.22.0 → 0.23.0

package/dist/index.js

@@ -1,13 +1,11 @@
 #!/usr/bin/env node
 
 // packages/cli/src/lib/cli.ts
-import { Command as Command3, program } from "commander";
+import { Command as Command5, program } from "commander";
 
-// packages/cli/src/lib/langs/dart.ts
+// packages/cli/src/lib/apiref.ts
 import { Command } from "commander";
-import { execFile, execSync } from "node:child_process";
-import { generate } from "@sdk-it/dart";
-import { augmentSpec, loadSpec } from "@sdk-it/spec";
+import { execa } from "execa";
 
 // packages/cli/src/lib/options.ts
 import { Option } from "commander";
@@ -23,8 +21,24 @@ function shellEnv(name) {
   return process.platform === "win32" ? `%${name}%` : `$${name}`;
 }
 
+// packages/cli/src/lib/apiref.ts
+var apiref_default = new Command("apiref").description("Generate APIREF").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).action(async (options) => {
+  await execa("nx", ["run", "apiref:build"], {
+    stdio: "inherit",
+    extendEnv: true,
+    env: {
+      VITE_SPEC: options.spec,
+      VITE_SDK_IT_OUTPUT: options.output
+    }
+  });
+});
+
 // packages/cli/src/lib/langs/dart.ts
-var dart_default = new Command("dart").description("Generate Dart SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-l, --language <language>", "Programming language for the SDK").option("-n, --name <name>", "Name of the generated client", "Client").option("-v, --verbose", "Verbose output", false).action(async (options) => {
+import { Command as Command2 } from "commander";
+import { execFile, execSync } from "node:child_process";
+import { generate } from "@sdk-it/dart";
+import { augmentSpec, loadSpec } from "@sdk-it/spec";
+var dart_default = new Command2("dart").description("Generate Dart SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-l, --language <language>", "Programming language for the SDK").option("-n, --name <name>", "Name of the generated client", "Client").option("-v, --verbose", "Verbose output", false).action(async (options) => {
   const spec = augmentSpec({ spec: await loadSpec(options.spec) }, true);
   await generate(spec, {
     output: options.output,
@@ -46,18 +60,2021 @@ var dart_default = new Command("dart").description("Generate Dart SDK").addOptio
   });
 });
 
+// packages/cli/src/lib/langs/python.ts
+import { Command as Command3 } from "commander";
+import { execFile as execFile2, execSync as execSync2 } from "node:child_process";
+
+// packages/python/dist/index.js
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { snakecase as snakecase2 } from "stringcase";
+import { isEmpty, isRef as isRef2, pascalcase as pascalcase2 } from "@sdk-it/core";
+import {
+  createWriterProxy,
+  writeFiles
+} from "@sdk-it/core/file-system.js";
+import {
+  augmentSpec as augmentSpec2,
+  cleanFiles,
+  forEachOperation,
+  isSuccessStatusCode,
+  parseJsonContentType,
+  readWriteMetadata
+} from "@sdk-it/spec";
+import { snakecase } from "stringcase";
+import { isRef, notRef, parseRef, pascalcase } from "@sdk-it/core";
+import { isPrimitiveSchema } from "@sdk-it/spec";
+var dispatcher_default = `"""HTTP dispatcher for making API requests."""
+
+import asyncio
+import logging
+from typing import Any, Dict, List, Optional, Union
+from urllib.parse import urljoin, urlparse
+
+import httpx
+from pydantic import BaseModel
+
+from .interceptors import Interceptor
+from .responses import ApiResponse, ErrorResponse
+
+
+class RequestConfig(BaseModel):
+    """Configuration for an HTTP request."""
+
+    method: str
+    url: str
+    headers: Optional[Dict[str, str]] = None
+    params: Optional[Dict[str, Any]] = None
+    json_data: Optional[Dict[str, Any]] = None
+    form_data: Optional[Dict[str, Any]] = None
+    files: Optional[Dict[str, Any]] = None
+    timeout: Optional[Union[float, httpx.Timeout]] = None
+    
+    class Config:
+        """Pydantic configuration."""
+        arbitrary_types_allowed = True
+
+
+class Dispatcher:
+    """HTTP client dispatcher with interceptor support."""
+
+    def __init__(
+        self, 
+        interceptors: Optional[List[Interceptor]] = None,
+        client: Optional[httpx.AsyncClient] = None,
+        timeout: Optional[Union[float, httpx.Timeout]] = None
+    ):
+        """Initialize the dispatcher.
+        
+        Args:
+            interceptors: List of interceptors to apply to requests/responses
+            client: Custom httpx.AsyncClient instance (creates default if None)
+            timeout: Default timeout for requests
+        """
+        self.interceptors = interceptors or []
+        self.client = client or httpx.AsyncClient(timeout=timeout)
+        self.logger = logging.getLogger(__name__)
+
+    async def __aenter__(self):
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        """Async context manager exit."""
+        await self.client.aclose()
+
+    async def request(self, config: RequestConfig) -> httpx.Response:
+        """Execute an HTTP request with interceptor processing.
+        
+        Args:
+            config: Request configuration
+            
+        Returns:
+            HTTP response after processing through interceptors
+            
+        Raises:
+            httpx.HTTPError: For HTTP-related errors
+            ValueError: For invalid request configuration
+        """
+        # Process request interceptors
+        processed_config = config
+        for interceptor in self.interceptors:
+            processed_config = await interceptor.process_request(processed_config)
+
+        # Prepare request arguments
+        request_kwargs = self._prepare_request_kwargs(processed_config)
+
+        try:
+            # Execute request
+            response = await self.client.request(**request_kwargs)
+            
+            # Process response interceptors (in reverse order)
+            for interceptor in reversed(self.interceptors):
+                response = await interceptor.process_response(response)
+
+            return response
+            
+        except httpx.RequestError as e:
+            self.logger.error(f"Request failed: {e}")
+            raise
+        except Exception as e:
+            self.logger.error(f"Unexpected error during request: {e}")
+            raise
+
+    def _prepare_request_kwargs(self, config: RequestConfig) -> Dict[str, Any]:
+        """Prepare keyword arguments for httpx request.
+        
+        Args:
+            config: Request configuration
+            
+        Returns:
+            Dictionary of kwargs for httpx.request
+            
+        Raises:
+            ValueError: If request configuration is invalid
+        """
+        if not config.method:
+            raise ValueError("Request method cannot be empty")
+        
+        if not config.url:
+            raise ValueError("Request URL cannot be empty")
+
+        request_kwargs = {
+            'method': config.method.upper(),
+            'url': config.url,
+            'headers': config.headers or {},
+            'params': config.params,
+            'timeout': config.timeout,
+        }
+
+        # Handle different content types
+        content_type_set = False
+        
+        if config.json_data is not None:
+            request_kwargs['json'] = config.json_data
+            if 'Content-Type' not in request_kwargs['headers']:
+                request_kwargs['headers']['Content-Type'] = 'application/json'
+            content_type_set = True
+            
+        elif config.form_data is not None:
+            request_kwargs['data'] = config.form_data
+            if 'Content-Type' not in request_kwargs['headers']:
+                request_kwargs['headers']['Content-Type'] = 'application/x-www-form-urlencoded'
+            content_type_set = True
+            
+        elif config.files is not None:
+            request_kwargs['files'] = config.files
+            # Don't set Content-Type for multipart/form-data - httpx will handle it automatically
+            content_type_set = True
+
+        # Validate that only one content type is set
+        content_fields = [config.json_data, config.form_data, config.files]
+        non_none_count = sum(1 for field in content_fields if field is not None)
+        
+        if non_none_count > 1:
+            raise ValueError(
+                "Only one of json_data, form_data, or files can be set in a single request"
+            )
+
+        return request_kwargs
+
+    async def json(self, config: RequestConfig) -> httpx.Response:
+        """Make a JSON request.
+        
+        Args:
+            config: Request configuration
+            
+        Returns:
+            HTTP response
+        """
+        return await self.request(config)
+
+    async def form(self, config: RequestConfig) -> httpx.Response:
+        """Make a form-encoded request.
+        
+        Args:
+            config: Request configuration
+            
+        Returns:
+            HTTP response
+        """
+        return await self.request(config)
+
+    async def multipart(self, config: RequestConfig) -> httpx.Response:
+        """Make a multipart/form-data request.
+        
+        Args:
+            config: Request configuration
+            
+        Returns:
+            HTTP response
+        """
+        return await self.request(config)
+
+    async def close(self):
+        """Close the HTTP client and clean up resources."""
+        await self.client.aclose()
+
+
+class Receiver:
+    """Response processor with interceptor support."""
+
+    def __init__(
+        self, 
+        interceptors: Optional[List[Interceptor]] = None,
+        logger: Optional[logging.Logger] = None
+    ):
+        """Initialize the receiver.
+        
+        Args:
+            interceptors: List of interceptors to apply to responses
+            logger: Custom logger instance
+        """
+        self.interceptors = interceptors or []
+        self.logger = logger or logging.getLogger(__name__)
+
+    async def json(
+        self, 
+        response: httpx.Response, 
+        success_model: Optional[type] = None, 
+        error_model: Optional[type] = None
+    ) -> Any:
+        """Process a JSON response.
+        
+        Args:
+            response: HTTP response to process
+            success_model: Pydantic model for successful responses
+            error_model: Pydantic model for error responses
+            
+        Returns:
+            Parsed response data, optionally as model instances
+            
+        Raises:
+            ErrorResponse: For HTTP error status codes
+            ValueError: For response parsing errors
+        """
+        # Process response interceptors
+        processed_response = response
+        for interceptor in self.interceptors:
+            processed_response = await interceptor.process_response(processed_response)
+
+        # Handle different status codes
+        if 200 <= processed_response.status_code < 300:
+            return await self._handle_success_response(
+                processed_response, success_model
+            )
+        else:
+            await self._handle_error_response(
+                processed_response, error_model
+            )
+
+    async def _handle_success_response(
+        self, 
+        response: httpx.Response, 
+        success_model: Optional[type] = None
+    ) -> Any:
+        """Handle successful response.
+        
+        Args:
+            response: HTTP response
+            success_model: Pydantic model for successful responses
+            
+        Returns:
+            Parsed response data
+            
+        Raises:
+            ValueError: For parsing errors
+        """
+        if not response.content:
+            return None
+
+        try:
+            data = response.json()
+            
+            if success_model:
+                if isinstance(data, list):
+                    return [success_model(**item) for item in data]
+                else:
+                    return success_model(**data)
+            
+            return data
+            
+        except Exception as e:
+            self.logger.error(f"Failed to parse success response: {e}")
+            raise ValueError(f"Failed to parse response: {e}")
+
+    async def _handle_error_response(
+        self, 
+        response: httpx.Response, 
+        error_model: Optional[type] = None
+    ) -> None:
+        """Handle error response.
+        
+        Args:
+            response: HTTP response
+            error_model: Pydantic model for error responses
+            
+        Raises:
+            ErrorResponse: Always raises with error details
+        """
+        error_data = {}
+        
+        if response.content:
+            try:
+                error_data = response.json()
+            except Exception:
+                # Fallback to text content if JSON parsing fails
+                error_data = {'message': response.text}
+
+        if error_model:
+            try:
+                error = error_model(**error_data)
+                raise ErrorResponse(error, response.status_code, dict(response.headers))
+            except Exception as e:
+                self.logger.warning(f"Failed to parse error with model {error_model}: {e}")
+
+        raise ErrorResponse(error_data, response.status_code, dict(response.headers))
+
+    async def stream(self, response: httpx.Response) -> httpx.Response:
+        """Return streaming response as-is.
+        
+        Args:
+            response: HTTP response
+            
+        Returns:
+            The unmodified streaming response
+        """
+        return response
+
+    async def text(self, response: httpx.Response) -> str:
+        """Get response as text.
+        
+        Args:
+            response: HTTP response
+            
+        Returns:
+            Response body as text
+            
+        Raises:
+            ErrorResponse: For HTTP error status codes
+        """
+        # Process response interceptors
+        processed_response = response
+        for interceptor in self.interceptors:
+            processed_response = await interceptor.process_response(processed_response)
+
+        if 200 <= processed_response.status_code < 300:
+            return processed_response.text
+        else:
+            error_data = {'message': processed_response.text}
+            raise ErrorResponse(error_data, processed_response.status_code, dict(processed_response.headers))
+
+    async def bytes(self, response: httpx.Response) -> bytes:
+        """Get response as bytes.
+        
+        Args:
+            response: HTTP response
+            
+        Returns:
+            Response body as bytes
+            
+        Raises:
+            ErrorResponse: For HTTP error status codes
+        """
+        # Process response interceptors
+        processed_response = response
+        for interceptor in self.interceptors:
+            processed_response = await interceptor.process_response(processed_response)
+
+        if 200 <= processed_response.status_code < 300:
+            return processed_response.content
+        else:
+            error_data = {'message': 'Binary response error'}
+            raise ErrorResponse(error_data, processed_response.status_code, dict(processed_response.headers))
+
+
+# Convenience functions for common use cases
+async def quick_request(
+    method: str,
+    url: str,
+    interceptors: Optional[List[Interceptor]] = None,
+    **kwargs
+) -> httpx.Response:
+    """Make a quick HTTP request with interceptors.
+    
+    Args:
+        method: HTTP method
+        url: Request URL
+        interceptors: List of interceptors to apply
+        **kwargs: Additional request configuration
+        
+    Returns:
+        HTTP response
+    """
+    config = RequestConfig(method=method, url=url, **kwargs)
+    
+    async with Dispatcher(interceptors=interceptors) as dispatcher:
+        return await dispatcher.request(config)
+
+
+async def quick_json_request(
+    method: str,
+    url: str,
+    json_data: Optional[Dict[str, Any]] = None,
+    interceptors: Optional[List[Interceptor]] = None,
+    success_model: Optional[type] = None,
+    error_model: Optional[type] = None,
+    **kwargs
+) -> Any:
+    """Make a quick JSON HTTP request with interceptors.
+    
+    Args:
+        method: HTTP method
+        url: Request URL
+        json_data: JSON data to send
+        interceptors: List of interceptors to apply
+        success_model: Pydantic model for successful responses
+        error_model: Pydantic model for error responses
+        **kwargs: Additional request configuration
+        
+    Returns:
+        Parsed JSON response
+    """
+    config = RequestConfig(method=method, url=url, json_data=json_data, **kwargs)
+    
+    async with Dispatcher(interceptors=interceptors) as dispatcher:
+        response = await dispatcher.request(config)
+        receiver = Receiver(interceptors=interceptors)
+        return await receiver.json(response, success_model, error_model)
+`;
+var interceptors_default = `"""HTTP interceptors for request/response processing."""
+
+import asyncio
+import logging
+import time
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, List, Any, Union
+from urllib.parse import urljoin
+
+import httpx
+
+from .dispatcher import RequestConfig
+
+
+class Interceptor(ABC):
+    """Base class for HTTP interceptors."""
+
+    @abstractmethod
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Process an outgoing request.
+
+        Args:
+            config: The request configuration to process
+
+        Returns:
+            The modified request configuration
+        """
+        pass
+
+    @abstractmethod
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Process an incoming response.
+
+        Args:
+            response: The HTTP response to process
+
+        Returns:
+            The processed response
+        """
+        pass
+
+
+class BaseUrlInterceptor(Interceptor):
+    """Interceptor that prepends base URL to relative URLs."""
+
+    def __init__(self, base_url: str):
+        """Initialize the base URL interceptor.
+
+        Args:
+            base_url: The base URL to prepend to relative URLs
+        """
+        self.base_url = base_url.rstrip('/')
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Prepend base URL if the request URL is relative.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The modified request configuration with absolute URL
+        """
+        if not config.url.startswith(('http://', 'https://')):
+            # Use urljoin for proper URL joining, ensuring single slash
+            config.url = urljoin(self.base_url + '/', config.url.lstrip('/'))
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Pass through response unchanged.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The unmodified response
+        """
+        return response
+
+
+class LoggingInterceptor(Interceptor):
+    """Interceptor that logs requests and responses using Python's logging module."""
+
+    def __init__(
+        self,
+        enabled: bool = True,
+        logger: Optional[logging.Logger] = None,
+        log_level: int = logging.INFO,
+        include_headers: bool = True,
+        include_sensitive_headers: bool = False
+    ):
+        """Initialize the logging interceptor.
+
+        Args:
+            enabled: Whether logging is enabled
+            logger: Custom logger instance (creates default if None)
+            log_level: Logging level to use
+            include_headers: Whether to log request/response headers
+            include_sensitive_headers: Whether to log sensitive headers like Authorization
+        """
+        self.enabled = enabled
+        self.logger = logger or logging.getLogger(__name__)
+        self.log_level = log_level
+        self.include_headers = include_headers
+        self.include_sensitive_headers = include_sensitive_headers
+        self._sensitive_headers = {'authorization', 'x-api-key', 'cookie', 'set-cookie'}
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Log outgoing request.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The unmodified request configuration
+        """
+        if not self.enabled:
+            return config
+
+        self.logger.log(self.log_level, f"\u2192 {config.method.upper()} {config.url}")
+
+        if self.include_headers and config.headers:
+            for key, value in config.headers.items():
+                if (key.lower() in self._sensitive_headers and
+                    not self.include_sensitive_headers):
+                    self.logger.log(self.log_level, f"  {key}: [REDACTED]")
+                else:
+                    self.logger.log(self.log_level, f"  {key}: {value}")
+
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Log incoming response.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The unmodified response
+        """
+        if not self.enabled:
+            return response
+
+        status_icon = "\u2713" if 200 <= response.status_code < 300 else "\u2717"
+        self.logger.log(
+            self.log_level,
+            f"\u2190 {status_icon} {response.status_code} {response.reason_phrase or ''}"
+        )
+
+        if self.include_headers and response.headers:
+            for key, value in response.headers.items():
+                if (key.lower() in self._sensitive_headers and
+                    not self.include_sensitive_headers):
+                    self.logger.log(self.log_level, f"  {key}: [REDACTED]")
+                else:
+                    self.logger.log(self.log_level, f"  {key}: {value}")
+
+        return response
+
+
+class AuthInterceptor(Interceptor):
+    """Interceptor that adds authentication headers."""
+
+    def __init__(
+        self,
+        token: Optional[str] = None,
+        api_key: Optional[str] = None,
+        api_key_header: str = 'X-API-Key',
+        auth_type: str = 'Bearer'
+    ):
+        """Initialize the authentication interceptor.
+
+        Args:
+            token: Bearer token for Authorization header
+            api_key: API key value
+            api_key_header: Header name for API key
+            auth_type: Type of authentication (Bearer, Basic, etc.)
+        """
+        self.token = token
+        self.api_key = api_key
+        self.api_key_header = api_key_header
+        self.auth_type = auth_type
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Add authentication headers.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The modified request configuration with auth headers
+        """
+        if config.headers is None:
+            config.headers = {}
+
+        if self.token:
+            config.headers['Authorization'] = f'{self.auth_type} {self.token}'
+        elif self.api_key:
+            config.headers[self.api_key_header] = self.api_key
+
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Pass through response unchanged.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The unmodified response
+        """
+        return response
+
+
+class RetryInterceptor(Interceptor):
+    """Interceptor that retries failed requests with exponential backoff."""
+
+    def __init__(
+        self,
+        max_retries: int = 3,
+        retry_delay: float = 1.0,
+        backoff_factor: float = 2.0,
+        retry_on_status: Optional[List[int]] = None,
+        retry_on_exceptions: Optional[List[type]] = None
+    ):
+        """Initialize the retry interceptor.
+
+        Args:
+            max_retries: Maximum number of retry attempts
+            retry_delay: Initial delay between retries in seconds
+            backoff_factor: Exponential backoff multiplier
+            retry_on_status: HTTP status codes that should trigger retries
+            retry_on_exceptions: Exception types that should trigger retries
+        """
+        self.max_retries = max_retries
+        self.retry_delay = retry_delay
+        self.backoff_factor = backoff_factor
+        self.retry_on_status = retry_on_status or [500, 502, 503, 504, 408, 429]
+        self.retry_on_exceptions = retry_on_exceptions or [
+            httpx.TimeoutException,
+            httpx.ConnectError,
+            httpx.RemoteProtocolError
+        ]
+        self._original_request_func = None
+        self.logger = logging.getLogger(__name__)
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Store original request for potential retries.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The unmodified request configuration
+        """
+        # Store the original config for retries
+        self._original_config = config.model_copy() if hasattr(config, 'model_copy') else config
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Check if response needs retry and handle accordingly.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The response (possibly after retries)
+        """
+        # For retry logic to work properly, it needs to be integrated at the dispatcher level
+        # This is a simplified version that just passes through
+        # In a full implementation, the retry logic would need access to the original request method
+        return response
+
+    async def execute_with_retry(self, request_func, *args, **kwargs) -> httpx.Response:
+        """Execute a request function with retry logic.
+
+        Args:
+            request_func: Function that executes the HTTP request
+            *args: Arguments to pass to request_func
+            **kwargs: Keyword arguments to pass to request_func
+
+        Returns:
+            The HTTP response after potential retries
+
+        Raises:
+            The last exception encountered if all retries fail
+        """
+        last_exception = None
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                response = await request_func(*args, **kwargs)
+
+                # Check if response status requires retry
+                if response.status_code not in self.retry_on_status:
+                    return response
+
+                if attempt == self.max_retries:
+                    self.logger.warning(
+                        f"Max retries ({self.max_retries}) reached for request. "
+                        f"Final status: {response.status_code}"
+                    )
+                    return response
+
+                # Wait before retry
+                delay = self.retry_delay * (self.backoff_factor ** attempt)
+                self.logger.info(
+                    f"Retrying request (attempt {attempt + 1}/{self.max_retries + 1}) "
+                    f"after {delay:.2f}s due to status {response.status_code}"
+                )
+                await asyncio.sleep(delay)
+
+            except Exception as e:
+                # Check if exception type requires retry
+                if not any(isinstance(e, exc_type) for exc_type in self.retry_on_exceptions):
+                    raise e
+
+                last_exception = e
+
+                if attempt == self.max_retries:
+                    self.logger.error(
+                        f"Max retries ({self.max_retries}) reached. "
+                        f"Final exception: {type(e).__name__}: {e}"
+                    )
+                    raise e
+
+                # Wait before retry
+                delay = self.retry_delay * (self.backoff_factor ** attempt)
+                self.logger.info(
+                    f"Retrying request (attempt {attempt + 1}/{self.max_retries + 1}) "
+                    f"after {delay:.2f}s due to {type(e).__name__}: {e}"
+                )
+                await asyncio.sleep(delay)
+
+
+class UserAgentInterceptor(Interceptor):
+    """Interceptor that adds a User-Agent header."""
+
+    def __init__(self, user_agent: str):
+        """Initialize the User-Agent interceptor.
+
+        Args:
+            user_agent: The User-Agent string to set
+        """
+        self.user_agent = user_agent
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Add User-Agent header if not already present.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The modified request configuration with User-Agent header
+        """
+        if config.headers is None:
+            config.headers = {}
+
+        # Only set User-Agent if not already present (case-insensitive check)
+        has_user_agent = any(
+            key.lower() == 'user-agent'
+            for key in config.headers.keys()
+        )
+
+        if not has_user_agent:
+            config.headers['User-Agent'] = self.user_agent
+
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Pass through response unchanged.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The unmodified response
+        """
+        return response
+
+
+class TimeoutInterceptor(Interceptor):
+    """Interceptor that sets request timeouts."""
+
+    def __init__(self, timeout: Union[float, httpx.Timeout]):
+        """Initialize the timeout interceptor.
+
+        Args:
+            timeout: Timeout value in seconds or httpx.Timeout object
+        """
+        self.timeout = timeout
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Set timeout for the request.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The modified request configuration with timeout
+        """
+        if config.timeout is None:
+            config.timeout = self.timeout
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Pass through response unchanged.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The unmodified response
+        """
+        return response
+
+
+class RateLimitInterceptor(Interceptor):
+    """Interceptor that implements client-side rate limiting."""
+
+    def __init__(self, max_requests: int, time_window: float = 60.0):
+        """Initialize the rate limit interceptor.
+
+        Args:
+            max_requests: Maximum number of requests allowed in the time window
+            time_window: Time window in seconds
+        """
+        self.max_requests = max_requests
+        self.time_window = time_window
+        self.requests = []
+        self._lock = asyncio.Lock()
+
+    async def process_request(self, config: RequestConfig) -> RequestConfig:
+        """Apply rate limiting before request.
+
+        Args:
+            config: The request configuration
+
+        Returns:
+            The unmodified request configuration
+        """
+        async with self._lock:
+            now = time.time()
+
+            # Remove requests outside the time window
+            self.requests = [req_time for req_time in self.requests
+                           if now - req_time < self.time_window]
+
+            # Check if we've exceeded the rate limit
+            if len(self.requests) >= self.max_requests:
+                # Calculate how long to wait
+                oldest_request = min(self.requests)
+                wait_time = self.time_window - (now - oldest_request)
+
+                if wait_time > 0:
+                    await asyncio.sleep(wait_time)
+
+            # Record this request
+            self.requests.append(now)
+
+        return config
+
+    async def process_response(self, response: httpx.Response) -> httpx.Response:
+        """Pass through response unchanged.
+
+        Args:
+            response: The HTTP response
+
+        Returns:
+            The unmodified response
+        """
+        return response
+
+
+# Factory functions for convenient interceptor creation
+def create_base_url_interceptor(base_url: str) -> BaseUrlInterceptor:
+    """Create a BaseUrlInterceptor instance.
+
+    Args:
+        base_url: The base URL to prepend to relative URLs
+
+    Returns:
+        Configured BaseUrlInterceptor instance
+    """
+    return BaseUrlInterceptor(base_url)
+
+
+def create_logging_interceptor(
+    enabled: bool = True,
+    log_level: int = logging.INFO,
+    include_headers: bool = True,
+    include_sensitive_headers: bool = False
+) -> LoggingInterceptor:
+    """Create a LoggingInterceptor instance.
+
+    Args:
+        enabled: Whether logging is enabled
+        log_level: Logging level to use
+        include_headers: Whether to log headers
+        include_sensitive_headers: Whether to log sensitive headers
+
+    Returns:
+        Configured LoggingInterceptor instance
+    """
+    return LoggingInterceptor(
+        enabled=enabled,
+        log_level=log_level,
+        include_headers=include_headers,
+        include_sensitive_headers=include_sensitive_headers
+    )
+
+
+def create_auth_interceptor(
+    token: Optional[str] = None,
+    api_key: Optional[str] = None,
+    api_key_header: str = 'X-API-Key',
+    auth_type: str = 'Bearer'
+) -> AuthInterceptor:
+    """Create an AuthInterceptor instance.
+
+    Args:
+        token: Bearer token for Authorization header
+        api_key: API key value
+        api_key_header: Header name for API key
+        auth_type: Type of authentication
+
+    Returns:
+        Configured AuthInterceptor instance
+    """
+    return AuthInterceptor(
+        token=token,
+        api_key=api_key,
+        api_key_header=api_key_header,
+        auth_type=auth_type
+    )
+
+
+def create_retry_interceptor(
+    max_retries: int = 3,
+    retry_delay: float = 1.0,
+    backoff_factor: float = 2.0,
+    retry_on_status: Optional[List[int]] = None
+) -> RetryInterceptor:
+    """Create a RetryInterceptor instance.
+
+    Args:
+        max_retries: Maximum number of retry attempts
+        retry_delay: Initial delay between retries in seconds
+        backoff_factor: Exponential backoff multiplier
+        retry_on_status: HTTP status codes that should trigger retries
+
+    Returns:
+        Configured RetryInterceptor instance
+    """
+    return RetryInterceptor(
+        max_retries=max_retries,
+        retry_delay=retry_delay,
+        backoff_factor=backoff_factor,
+        retry_on_status=retry_on_status
+    )
+
+
+def create_user_agent_interceptor(user_agent: str) -> UserAgentInterceptor:
+    """Create a UserAgentInterceptor instance.
+
+    Args:
+        user_agent: The User-Agent string to set
+
+    Returns:
+        Configured UserAgentInterceptor instance
+    """
+    return UserAgentInterceptor(user_agent)
+`;
+var responses_default = `"""HTTP response models and exceptions."""
+
+from typing import Any, Dict, Optional, Union
+
+import httpx
+from pydantic import BaseModel
+
+
+class ApiResponse(BaseModel):
+    """Base class for API responses."""
+
+    status_code: int
+    headers: Dict[str, str]
+    data: Any
+
+    class Config:
+        """Pydantic configuration."""
+        arbitrary_types_allowed = True
+
+
+class SuccessResponse(ApiResponse):
+    """Represents a successful API response."""
+
+    def __init__(self, data: Any, status_code: int = 200, headers: Optional[Dict[str, str]] = None):
+        """Initialize success response.
+
+        Args:
+            data: Response data
+            status_code: HTTP status code
+            headers: Response headers
+        """
+        super().__init__(
+            status_code=status_code,
+            headers=headers or {},
+            data=data
+        )
+
+
+class ErrorResponse(Exception):
+    """Exception raised for HTTP error responses."""
+
+    def __init__(
+        self,
+        data: Any,
+        status_code: int,
+        headers: Optional[Dict[str, str]] = None,
+        message: Optional[str] = None
+    ):
+        """Initialize error response.
+
+        Args:
+            data: Error response data
+            status_code: HTTP status code
+            headers: Response headers
+            message: Custom error message
+        """
+        self.data = data
+        self.status_code = status_code
+        self.headers = headers or {}
+        self.message = message or f"HTTP {status_code} Error"
+
+        super().__init__(self.message)
+
+    def __str__(self) -> str:
+        """String representation of the error."""
+        return f"ErrorResponse(status_code={self.status_code}, message='{self.message}')"
+
+    def __repr__(self) -> str:
+        """Detailed string representation of the error."""
+        return (
+            f"ErrorResponse(status_code={self.status_code}, "
+            f"message='{self.message}', data={self.data})"
+        )
+
+
+class TimeoutError(ErrorResponse):
+    """Exception raised for request timeouts."""
+
+    def __init__(self, message: str = "Request timed out"):
+        """Initialize timeout error.
+
+        Args:
+            message: Error message
+        """
+        super().__init__(
+            data={'error': 'timeout'},
+            status_code=408,
+            message=message
+        )
+
+
+class ConnectionError(ErrorResponse):
+    """Exception raised for connection errors."""
+
+    def __init__(self, message: str = "Connection failed"):
+        """Initialize connection error.
+
+        Args:
+            message: Error message
+        """
+        super().__init__(
+            data={'error': 'connection'},
+            status_code=503,
+            message=message
+        )
+
+
+class BadRequestError(ErrorResponse):
+    """Exception raised for 400 Bad Request errors."""
+
+    def __init__(self, data: Any = None, message: str = "Bad Request"):
+        """Initialize bad request error.
+
+        Args:
+            data: Error data
+            message: Error message
+        """
+        super().__init__(
+            data=data or {'error': 'bad_request'},
+            status_code=400,
+            message=message
+        )
+
+
+class UnauthorizedError(ErrorResponse):
+    """Exception raised for 401 Unauthorized errors."""
+
+    def __init__(self, data: Any = None, message: str = "Unauthorized"):
+        """Initialize unauthorized error.
+
+        Args:
+            data: Error data
+            message: Error message
+        """
+        super().__init__(
+            data=data or {'error': 'unauthorized'},
+            status_code=401,
+            message=message
+        )
+
+
+class ForbiddenError(ErrorResponse):
+    """Exception raised for 403 Forbidden errors."""
+
+    def __init__(self, data: Any = None, message: str = "Forbidden"):
+        """Initialize forbidden error.
+
+        Args:
+            data: Error data
+            message: Error message
+        """
+        super().__init__(
+            data=data or {'error': 'forbidden'},
+            status_code=403,
+            message=message
+        )
+
+
+class NotFoundError(ErrorResponse):
+    """Exception raised for 404 Not Found errors."""
+
+    def __init__(self, data: Any = None, message: str = "Not Found"):
+        """Initialize not found error.
+
+        Args:
+            data: Error data
+            message: Error message
+        """
+        super().__init__(
+            data=data or {'error': 'not_found'},
+            status_code=404,
+            message=message
+        )
+
+
+class InternalServerError(ErrorResponse):
+    """Exception raised for 500 Internal Server Error."""
+
+    def __init__(self, data: Any = None, message: str = "Internal Server Error"):
+        """Initialize internal server error.
+
+        Args:
+            data: Error data
+            message: Error message
+        """
+        super().__init__(
+            data=data or {'error': 'internal_server_error'},
+            status_code=500,
+            message=message
+        )
+
+
+def create_error_from_response(response: httpx.Response) -> ErrorResponse:
+    """Create appropriate error exception from HTTP response.
+
+    Args:
+        response: HTTP response
+
+    Returns:
+        Appropriate error exception
+    """
+    status_code = response.status_code
+    headers = dict(response.headers)
+
+    # Try to parse error data
+    try:
+        data = response.json()
+    except Exception:
+        data = {'message': response.text}
+
+    # Create specific error types based on status code
+    error_classes = {
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalServerError,
+    }
+
+    error_class = error_classes.get(status_code, ErrorResponse)
+
+    if error_class == ErrorResponse:
+        return ErrorResponse(data, status_code, headers)
+    else:
+        return error_class(data)
+`;
+function coerceObject(schema) {
+  schema = structuredClone(schema);
+  if (schema["x-properties"]) {
+    schema.properties = {
+      ...schema.properties ?? {},
+      ...schema["x-properties"] ?? {}
+    };
+  }
+  if (schema["x-required"]) {
+    schema.required = Array.from(
+      /* @__PURE__ */ new Set([
+        ...Array.isArray(schema.required) ? schema.required : [],
+        ...schema["x-required"] || []
+      ])
+    );
+  }
+  return schema;
+}
+var PythonEmitter = class {
+  #spec;
+  #emitHandler;
+  #emitHistory = /* @__PURE__ */ new Set();
+  #typeCache = /* @__PURE__ */ new Map();
+  // Cache for resolved types
+  #emit(name, content, schema) {
+    if (this.#emitHistory.has(content)) {
+      return;
+    }
+    this.#emitHistory.add(content);
+    this.#emitHandler?.(name, content, schema);
+  }
+  constructor(spec) {
+    this.#spec = spec;
+  }
+  onEmit(emit) {
+    this.#emitHandler = emit;
+  }
+  #formatFieldName(name) {
+    let fieldName = snakecase(name);
+    const reservedKeywords = [
+      "class",
+      "def",
+      "if",
+      "else",
+      "elif",
+      "while",
+      "for",
+      "try",
+      "except",
+      "finally",
+      "with",
+      "as",
+      "import",
+      "from",
+      "global",
+      "nonlocal",
+      "lambda",
+      "yield",
+      "return",
+      "pass",
+      "break",
+      "continue",
+      "True",
+      "False",
+      "None",
+      "and",
+      "or",
+      "not",
+      "in",
+      "is"
+    ];
+    if (reservedKeywords.includes(fieldName)) {
+      fieldName = `${fieldName}_`;
+    }
+    return fieldName;
+  }
+  #ref(ref) {
+    const cacheKey = ref.$ref;
+    if (this.#typeCache.has(cacheKey)) {
+      return this.#typeCache.get(cacheKey);
+    }
+    const refInfo = parseRef(ref.$ref);
+    const refName = refInfo.model;
+    const className = pascalcase(refName);
+    const result = {
+      type: className,
+      content: "",
+      use: className,
+      fromJson: `${className}.parse_obj`,
+      simple: false
+    };
+    this.#typeCache.set(cacheKey, result);
+    return result;
+  }
+  #oneOf(variants, context) {
+    const variantTypes = variants.map((variant) => this.handle(variant, context)).map((result) => result.type || "Any").filter((type, index, arr) => arr.indexOf(type) === index);
+    if (variantTypes.length === 0) {
+      return {
+        type: "Any",
+        content: "",
+        use: "Any",
+        fromJson: "Any",
+        simple: true
+      };
+    }
+    if (variantTypes.length === 1) {
+      return {
+        type: variantTypes[0],
+        content: "",
+        use: variantTypes[0],
+        fromJson: variantTypes[0],
+        simple: true
+      };
+    }
+    const unionType = `Union[${variantTypes.join(", ")}]`;
+    return {
+      type: unionType,
+      content: "",
+      use: unionType,
+      fromJson: unionType,
+      simple: true
+    };
+  }
+  #object(className, schema, context) {
+    const { properties = {}, required = [] } = coerceObject(schema);
+    const fields = [];
+    let baseClass = "BaseModel";
+    if (schema.allOf) {
+      const bases = schema.allOf.filter(notRef).map((s) => this.handle(s, context)).filter((result) => result.type).map((result) => result.type);
+      if (bases.length > 0 && bases[0]) {
+        baseClass = bases[0];
+      }
+    }
+    for (const [propName, propSchema] of Object.entries(properties)) {
+      if (isRef(propSchema)) {
+        const refResult = this.#ref(propSchema);
+        const refInfo = parseRef(propSchema.$ref);
+        const refName = refInfo.model;
+        const pythonType = pascalcase(refName);
+        const fieldName = this.#formatFieldName(propName);
+        const isRequired = required.includes(propName);
+        const fieldType = isRequired ? pythonType : `Optional[${pythonType}]`;
+        const defaultValue = isRequired ? "" : " = None";
+        fields.push(`    ${fieldName}: ${fieldType}${defaultValue}`);
+      } else {
+        const result = this.handle(propSchema, { ...context, name: propName });
+        const fieldName = this.#formatFieldName(propName);
+        const isRequired = required.includes(propName);
+        let fieldType = result.type || "Any";
+        if (!isRequired) {
+          fieldType = `Optional[${fieldType}]`;
+        }
+        const defaultValue = isRequired ? "" : " = None";
+        let fieldDef = `    ${fieldName}: ${fieldType}${defaultValue}`;
+        if (fieldName !== propName) {
+          fieldDef = `    ${fieldName}: ${fieldType} = Field(alias='${propName}'${defaultValue ? ", default=None" : ""})`;
+        }
+        if (propSchema.description) {
+          fieldDef += `  # ${propSchema.description}`;
+        }
+        fields.push(fieldDef);
+      }
+    }
+    if (schema.oneOf || schema.anyOf) {
+      const unionResult = this.#oneOf(
+        schema.oneOf || schema.anyOf || [],
+        context
+      );
+      fields.push(`    value: ${unionResult.type}`);
+    }
+    if (schema.additionalProperties && typeof schema.additionalProperties === "object") {
+      const addlResult = this.handle(schema.additionalProperties, context);
+      fields.push(
+        `    additional_properties: Optional[Dict[str, ${addlResult.type || "Any"}]] = None`
+      );
+    }
+    const docstring = schema.description ? `    """${schema.description}"""
+` : "";
+    let requestConfigMethod = "";
+    if (schema["x-inputname"]) {
+      requestConfigMethod = `
+    def to_request_config(self, config: RequestConfig) -> RequestConfig:
+        """Convert this input model to request configuration."""
+        # Handle path parameters
+        path_params = {}
+        for key, value in self.dict(exclude_none=True).items():
+            if key in config.url:
+                path_params[key] = str(value)
+                config.url = config.url.replace(f'{{{key}}}', str(value))
+
+        # Handle query parameters
+        query_params = {k: v for k, v in self.dict(exclude_none=True).items()
+                       if k not in path_params}
+        if query_params:
+            config.params = query_params
+
+        return config
+`;
+    }
+    const content = `class ${className}(${baseClass}):
+${docstring}${fields.length > 0 ? fields.join("\n") : "    pass"}${requestConfigMethod}
+`;
+    this.#emit(className, content, schema);
+    return {
+      type: className,
+      content,
+      use: className,
+      fromJson: `${className}.parse_obj`,
+      simple: false
+    };
+  }
+  #primitive(schema, context) {
+    const { type, format } = schema;
+    const nullable = schema.nullable;
+    let pythonType = "Any";
+    switch (type) {
+      case "string":
+        if (format === "date-time") {
+          pythonType = "datetime";
+        } else if (format === "date") {
+          pythonType = "date";
+        } else if (format === "uuid") {
+          pythonType = "UUID";
+        } else if (format === "binary" || format === "byte") {
+          pythonType = "bytes";
+        } else {
+          pythonType = "str";
+        }
+        break;
+      case "integer":
+        if (format === "int64") {
+          pythonType = "int";
+        } else {
+          pythonType = "int";
+        }
+        break;
+      case "number":
+        pythonType = "float";
+        break;
+      case "boolean":
+        pythonType = "bool";
+        break;
+      default:
+        pythonType = "Any";
+    }
+    if (nullable) {
+      pythonType = `Optional[${pythonType}]`;
+    }
+    return {
+      type: pythonType,
+      content: "",
+      use: pythonType,
+      fromJson: pythonType,
+      simple: true,
+      nullable
+    };
+  }
+  #array(schema, context) {
+    const itemsSchema = schema.items;
+    if (!itemsSchema) {
+      return {
+        type: "List[Any]",
+        content: "",
+        use: "List[Any]",
+        fromJson: "list",
+        simple: true
+      };
+    }
+    const itemsResult = this.handle(itemsSchema, context);
+    const listType = `List[${itemsResult.type || "Any"}]`;
+    return {
+      type: listType,
+      content: itemsResult.content,
+      use: listType,
+      fromJson: `List[${itemsResult.fromJson || itemsResult.type}]`,
+      simple: true
+    };
+  }
+  #enum(schema, context) {
+    const { enum: enumValues } = schema;
+    if (!enumValues || enumValues.length === 0) {
+      return this.#primitive(schema, context);
+    }
+    if (!context.name) {
+      throw new Error("Enum schemas must have a name in context");
+    }
+    const className = pascalcase(context.name);
+    const enumItems = enumValues.map((value, index) => {
+      const name = typeof value === "string" ? value.toUpperCase().replace(/[^A-Z0-9]/g, "_") : `VALUE_${index}`;
+      const pythonValue = typeof value === "string" ? `'${value}'` : String(value);
+      return `    ${name} = ${pythonValue}`;
+    });
+    const content = `class ${className}(Enum):
+    """Enumeration for ${context.name}."""
+${enumItems.join("\n")}
+`;
+    this.#emit(className, content, schema);
+    return {
+      type: className,
+      content,
+      use: className,
+      fromJson: className,
+      simple: false
+    };
+  }
+  #const(schema, context) {
+    const { const: constValue } = schema;
+    if (typeof constValue === "string") {
+      return {
+        type: `Literal['${constValue}']`,
+        content: "",
+        use: `Literal['${constValue}']`,
+        fromJson: `'${constValue}'`,
+        simple: true,
+        literal: constValue
+      };
+    }
+    return {
+      type: `Literal[${JSON.stringify(constValue)}]`,
+      content: "",
+      use: `Literal[${JSON.stringify(constValue)}]`,
+      fromJson: JSON.stringify(constValue),
+      simple: true,
+      literal: constValue
+    };
+  }
+  handle(schema, context = {}) {
+    if (isRef(schema)) {
+      return this.#ref(schema);
+    }
+    if ("const" in schema && schema.const !== void 0) {
+      return this.#const(schema, context);
+    }
+    if (schema.enum) {
+      return this.#enum(schema, context);
+    }
+    if (schema.type === "array") {
+      return this.#array(schema, context);
+    }
+    if (schema.oneOf || schema.anyOf) {
+      return this.#oneOf(schema.oneOf || schema.anyOf || [], context);
+    }
+    if (schema.type === "object" || schema.properties || schema.allOf || schema.oneOf || schema.anyOf) {
+      if (!context.name) {
+        throw new Error("Object schemas must have a name in context");
+      }
+      const className = pascalcase(context.name);
+      return this.#object(className, schema, context);
+    }
+    if (isPrimitiveSchema(schema)) {
+      return this.#primitive(schema, context);
+    }
+    return {
+      type: "Any",
+      content: "",
+      use: "Any",
+      fromJson: "Any",
+      simple: true
+    };
+  }
+};
+async function generate2(openapi, settings) {
+  const spec = augmentSpec2({ spec: openapi }, true);
+  const clientName = settings.name || "Client";
+  const output = settings.output;
+  const { writer, files: writtenFiles } = createWriterProxy(
+    settings.writer ?? writeFiles,
+    settings.output
+  );
+  settings.writer = writer;
+  settings.readFolder ??= async (folder) => {
+    const files = await readdir(folder, { withFileTypes: true });
+    return files.map((file) => ({
+      fileName: file.name,
+      filePath: join(file.parentPath, file.name),
+      isFolder: file.isDirectory()
+    }));
+  };
+  const groups = {};
+  forEachOperation(spec, (entry, operation) => {
+    console.log(`Processing ${entry.method} ${entry.path}`);
+    const group = groups[entry.groupName] ??= {
+      className: `${pascalcase2(entry.groupName)}Api`,
+      methods: []
+    };
+    const input = toInputs(spec, { entry, operation });
+    const response = toOutput(spec, operation);
+    const methodName = snakecase2(
+      operation.operationId || `${entry.method}_${entry.path.replace(/[^a-zA-Z0-9]/g, "_")}`
+    );
+    const returnType = response ? response.returnType : "httpx.Response";
+    const docstring = operation.summary || operation.description ? `        """${operation.summary || operation.description}"""` : "";
+    group.methods.push(`
+    async def ${methodName}(self${input.haveInput ? `, input_data: ${input.inputName}` : ""}) -> ${returnType}:
+${docstring}
+        config = RequestConfig(
+            method='${entry.method.toUpperCase()}',
+            url='${entry.path}',
+        )
+
+        ${input.haveInput ? "config = input_data.to_request_config(config)" : ""}
+
+        response = await self.dispatcher.${input.contentType}(config)
+        ${response ? `return await self.receiver.json(response, ${response.successModel || "None"}, ${response.errorModel || "None"})` : "return response"}
+    `);
+  });
+  const emitter = new PythonEmitter(spec);
+  const models = await serializeModels(spec, emitter);
+  const apiClasses = Object.entries(groups).reduce(
+    (acc, [name, { className, methods }]) => {
+      const fileName = `api/${snakecase2(name)}_api.py`;
+      const imports = [
+        "from typing import Optional",
+        "import httpx",
+        "",
+        "from ..http.dispatcher import Dispatcher, RequestConfig",
+        "from ..http.responses import Receiver",
+        "from ..inputs import *",
+        "from ..outputs import *",
+        "from ..models import *",
+        ""
+      ].join("\n");
+      acc[fileName] = `${imports}
+class ${className}:
+    """API client for ${name} operations."""
+
+    def __init__(self, dispatcher: Dispatcher, receiver: Receiver):
+        self.dispatcher = dispatcher
+        self.receiver = receiver
+${methods.join("\n")}
+`;
+      return acc;
+    },
+    {}
+  );
+  const apiImports = Object.keys(groups).map(
+    (name) => `from .api.${snakecase2(name)}_api import ${pascalcase2(name)}Api`
+  ).join("\\n");
+  const apiProperties = Object.keys(groups).map(
+    (name) => `        self.${snakecase2(name)} = ${pascalcase2(name)}Api(dispatcher, receiver)`
+  ).join("\\n");
+  const clientCode = `"""Main API client."""
+
+from typing import Optional, List
+import httpx
+
+${apiImports}
+from .http.dispatcher import Dispatcher, RequestConfig
+from .http.responses import Receiver
+from .http.interceptors import (
+    Interceptor,
+    BaseUrlInterceptor,
+    LoggingInterceptor,
+    AuthInterceptor,
+    UserAgentInterceptor,
+)
+
+
+class ${clientName}:
+    """Main API client for the SDK."""
+
+    def __init__(
+        self,
+        base_url: str,
+        token: Optional[str] = None,
+        api_key: Optional[str] = None,
+        api_key_header: str = 'X-API-Key',
+        enable_logging: bool = False,
+        user_agent: Optional[str] = None,
+        custom_interceptors: Optional[List[Interceptor]] = None,
+    ):
+        """
+        Initialize the API client.
+
+        Args:
+            base_url: Base URL for the API
+            token: Bearer token for authentication
+            api_key: API key for authentication
+            api_key_header: Header name for API key authentication
+            enable_logging: Enable request/response logging
+            user_agent: Custom User-Agent header
+            custom_interceptors: Additional custom interceptors
+        """
+        self.base_url = base_url
+
+        # Build interceptor chain
+        interceptors = []
+
+        # Base URL interceptor (always first)
+        interceptors.append(BaseUrlInterceptor(base_url))
+
+        # Authentication interceptor
+        if token or api_key:
+            interceptors.append(AuthInterceptor(token=token, api_key=api_key, api_key_header=api_key_header))
+
+        # User agent interceptor
+        if user_agent:
+            interceptors.append(UserAgentInterceptor(user_agent))
+
+        # Logging interceptor
+        if enable_logging:
+            interceptors.append(LoggingInterceptor())
+
+        # Custom interceptors
+        if custom_interceptors:
+            interceptors.extend(custom_interceptors)
+
+        # Initialize dispatcher and receiver
+        self.dispatcher = Dispatcher(interceptors)
+        self.receiver = Receiver(interceptors)
+
+        # Initialize API clients
+${apiProperties}
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, exc_type, exc_val, exc_tb):
+        await self.close()
+
+    async def close(self):
+        """Close the HTTP client."""
+        await self.dispatcher.close()
+`;
+  await settings.writer(output, {
+    ...models,
+    ...apiClasses,
+    "client.py": clientCode,
+    "http/dispatcher.py": dispatcher_default,
+    "http/interceptors.py": interceptors_default,
+    "http/responses.py": responses_default,
+    "__init__.py": `"""SDK package."""
+
+from .client import ${clientName}
+
+__all__ = ['${clientName}']
+`
+  });
+  if (settings.mode === "full") {
+    const requirements = `# HTTP client
+httpx>=0.24.0,<1.0.0
+
+# Data validation and serialization
+pydantic>=2.0.0,<3.0.0
+
+# Enhanced type hints
+typing-extensions>=4.0.0
+
+# Optional: For better datetime handling
+python-dateutil>=2.8.0
+`;
+    await settings.writer(output, {
+      "requirements.txt": requirements
+    });
+  }
+  const metadata = await readWriteMetadata(
+    settings.output,
+    Array.from(writtenFiles)
+  );
+  if (settings.cleanup !== false && writtenFiles.size > 0) {
+    await cleanFiles(metadata.content, settings.output, [
+      "/__init__.py",
+      "requirements.txt",
+      "/metadata.json"
+    ]);
+  }
+  await settings.writer(output, {
+    "models/__init__.py": await generateModuleInit(
+      join(output, "models"),
+      settings.readFolder
+    ),
+    "inputs/__init__.py": await generateModuleInit(
+      join(output, "inputs"),
+      settings.readFolder
+    ),
+    "outputs/__init__.py": await generateModuleInit(
+      join(output, "outputs"),
+      settings.readFolder
+    ),
+    "api/__init__.py": await generateModuleInit(
+      join(output, "api"),
+      settings.readFolder
+    ),
+    "http/__init__.py": `"""HTTP utilities."""
+
+from .dispatcher import Dispatcher, RequestConfig
+from .interceptors import *
+from .responses import *
+
+__all__ = [
+    'Dispatcher',
+    'RequestConfig',
+    'ApiResponse',
+    'ErrorResponse',
+    'Interceptor',
+    'BaseUrlInterceptor',
+    'LoggingInterceptor',
+    'AuthInterceptor',
+]
+`
+  });
+  if (settings.formatCode) {
+    await settings.formatCode({ output: settings.output });
+  }
+}
+async function generateModuleInit(folder, readFolder) {
+  try {
+    const files = await readFolder(folder);
+    const pyFiles = files.filter(
+      (file) => file.fileName.endsWith(".py") && file.fileName !== "__init__.py"
+    ).map((file) => file.fileName.replace(".py", ""));
+    if (pyFiles.length === 0) {
+      return '"""Package module."""\n';
+    }
+    const imports = pyFiles.map((name) => `from .${name} import *`).join("\n");
+    return `"""Package module."""
+
+${imports}
+`;
+  } catch {
+    return '"""Package module."""\\n';
+  }
+}
+function toInputs(spec, { entry, operation }) {
+  const inputName = entry.inputName || "Input";
+  const haveInput = !isEmpty(operation.parameters) || !isEmpty(operation.requestBody);
+  let contentType = "json";
+  if (operation.requestBody && !isRef2(operation.requestBody)) {
+    const content = operation.requestBody.content;
+    if (content) {
+      const contentTypes = Object.keys(content);
+      if (contentTypes.some((type) => type.includes("multipart"))) {
+        contentType = "multipart";
+      } else if (contentTypes.some((type) => type.includes("form"))) {
+        contentType = "form";
+      }
+    }
+  }
+  return {
+    inputName,
+    haveInput,
+    contentType
+  };
+}
+function toOutput(spec, operation) {
+  if (!operation.responses) {
+    return null;
+  }
+  const successResponse = Object.entries(operation.responses).find(
+    ([code]) => isSuccessStatusCode(Number(code))
+  );
+  if (!successResponse) {
+    return null;
+  }
+  const [statusCode, response] = successResponse;
+  if (isRef2(response)) {
+    return null;
+  }
+  const content = response.content;
+  if (!content) {
+    return { returnType: "None", successModel: null, errorModel: null };
+  }
+  const jsonContent = Object.entries(content).find(
+    ([type]) => parseJsonContentType(type)
+  );
+  if (!jsonContent) {
+    return {
+      returnType: "httpx.Response",
+      successModel: null,
+      errorModel: null
+    };
+  }
+  const [, mediaType] = jsonContent;
+  const schema = mediaType.schema;
+  if (!schema || isRef2(schema)) {
+    return { returnType: "Any", successModel: null, errorModel: null };
+  }
+  const emitter = new PythonEmitter(spec);
+  const result = emitter.handle(schema, {});
+  return {
+    returnType: result.type || "Any",
+    successModel: result.type,
+    errorModel: null
+    // TODO: Handle error models
+  };
+}
+async function serializeModels(spec, emitter) {
+  const models = {};
+  const standardImports = [
+    "from typing import Any, Dict, List, Optional, Union, Literal",
+    "from pydantic import BaseModel, Field",
+    "from datetime import datetime, date",
+    "from uuid import UUID",
+    "from enum import Enum"
+  ].join("\n");
+  emitter.onEmit((name, content, schema) => {
+    const fullContent = `${standardImports}
+${schema["x-inputname"] ? "from ..http.dispatcher import RequestConfig" : ""}
+
+
+${content}`;
+    if (schema["x-inputname"]) {
+      models[`inputs/${snakecase2(name)}.py`] = fullContent;
+    } else if (schema["x-response-name"]) {
+      models[`outputs/${snakecase2(name)}.py`] = fullContent;
+    } else {
+      models[`models/${snakecase2(name)}.py`] = fullContent;
+    }
+  });
+  if (spec.components?.schemas) {
+    for (const [name, schema] of Object.entries(spec.components.schemas)) {
+      if (!isRef2(schema)) {
+        emitter.handle(schema, { name });
+      }
+    }
+  }
+  return models;
+}
+
+// packages/cli/src/lib/langs/python.ts
+import { augmentSpec as augmentSpec3, loadSpec as loadSpec2 } from "@sdk-it/spec";
+var python_default = new Command3("python").description("Generate Python SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(true)).option("-l, --language <language>", "Programming language for the SDK").option("-n, --name <n>", "Name of the generated client", "Client").option("-v, --verbose", "Verbose output", false).option("--formatter <formatter>", "Formatter to use for the generated code").action(async (options) => {
+  const spec = augmentSpec3({ spec: await loadSpec2(options.spec) }, true);
+  await generate2(spec, {
+    output: options.output,
+    mode: options.mode || "full",
+    name: options.name,
+    formatCode: ({ output }) => {
+      if (options.formatter) {
+        const [command2, ...args] = options.formatter.split(" ");
+        execFile2(command2, args, {
+          env: { ...process.env, SDK_IT_OUTPUT: output }
+        });
+      } else {
+        try {
+          execSync2(`black ${shellEnv("SDK_IT_OUTPUT")}`, {
+            env: { ...process.env, SDK_IT_OUTPUT: output },
+            stdio: options.verbose ? "inherit" : "pipe"
+          });
+        } catch {
+          try {
+            execSync2(`ruff format ${shellEnv("SDK_IT_OUTPUT")}`, {
+              env: { ...process.env, SDK_IT_OUTPUT: output },
+              stdio: options.verbose ? "inherit" : "pipe"
+            });
+          } catch {
+            if (options.verbose) {
+              console.warn(
+                "No Python formatter found (black or ruff). Skipping formatting."
+              );
+            }
+          }
+        }
+      }
+    }
+  });
+});
+
 // packages/cli/src/lib/langs/typescript.ts
-import { Command as Command2, Option as Option2 } from "commander";
+import { Command as Command4, Option as Option2 } from "commander";
 import { publish } from "libnpmpublish";
-import { execFile as execFile2, execSync as execSync2, spawnSync } from "node:child_process";
+import { execFile as execFile3, execSync as execSync3, spawnSync } from "node:child_process";
 import { readFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import getAuthToken from "registry-auth-token";
-import { writeFiles } from "@sdk-it/core/file-system.js";
-import { augmentSpec as augmentSpec2, loadSpec as loadSpec2 } from "@sdk-it/spec";
-import { generate as generate2 } from "@sdk-it/typescript";
-var command = new Command2("typescript").alias("ts").description("Generate TypeScript SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(false)).option(
+import { writeFiles as writeFiles2 } from "@sdk-it/core/file-system.js";
+import { augmentSpec as augmentSpec4, loadSpec as loadSpec3 } from "@sdk-it/spec";
+import { generate as generate3 } from "@sdk-it/typescript";
+var command = new Command4("typescript").alias("ts").description("Generate TypeScript SDK").addOption(specOption.makeOptionMandatory(true)).addOption(outputOption.makeOptionMandatory(false)).option(
   "--useTsExtension [value]",
   "Use .ts extension for generated files",
   (value) => value === "false" ? false : true,
@@ -94,9 +2111,9 @@ var command = new Command2("typescript").alias("ts").description("Generate TypeS
     });
     return;
   }
-  const spec = augmentSpec2(
+  const spec = augmentSpec4(
     {
-      spec: await loadSpec2(options.spec),
+      spec: await loadSpec3(options.spec),
       responses: { flattenErrorResponses: true }
     },
     false
@@ -112,8 +2129,8 @@ var command = new Command2("typescript").alias("ts").description("Generate TypeS
   }
 });
 async function emitLocal(spec, options) {
-  await generate2(spec, {
-    writer: writeFiles,
+  await generate3(spec, {
+    writer: writeFiles2,
     output: options.output,
     mode: options.mode || "minimal",
     name: options.name,
@@ -127,7 +2144,7 @@ async function emitLocal(spec, options) {
     formatCode: ({ env, output }) => {
       if (options.formatter) {
         const [command2, ...args] = options.formatter.split(" ");
-        execFile2(command2, args, {
+        execFile3(command2, args, {
           env: { ...env, SDK_IT_OUTPUT: output }
         });
       } else if (options.defaultFormatter) {
@@ -144,7 +2161,7 @@ async function emitLocal(spec, options) {
   });
   if (options.install && options.mode === "full") {
     console.log("Installing dependencies...");
-    execSync2("npm install", {
+    execSync3("npm install", {
       cwd: options.output,
       stdio: options.verbose ? "inherit" : "pipe"
     });
@@ -153,7 +2170,7 @@ async function emitLocal(spec, options) {
 async function emitRemote(spec, options) {
   const registry = options.publish === "npm" ? "https://registry.npmjs.org/" : options.publish === "github" ? "https://npm.pkg.github.com/" : options.publish;
   console.log("Publishing to registry:", registry);
-  const path = join(tmpdir(), crypto.randomUUID());
+  const path = join2(tmpdir(), crypto.randomUUID());
   await emitLocal(spec, {
     ...options,
     output: path,
@@ -161,7 +2178,7 @@ async function emitRemote(spec, options) {
     mode: "full"
   });
   const manifest = JSON.parse(
-    await readFile(join(path, "package.json"), "utf-8")
+    await readFile(join2(path, "package.json"), "utf-8")
   );
   const registryUrl = new URL(registry);
   const npmrc = process.env.NPM_TOKEN ? {
@@ -176,9 +2193,9 @@ async function emitRemote(spec, options) {
       "No npm auth token found in .npmrc or environment. please provide NPM_TOKEN."
     );
   }
-  const packResult = execSync2("npm pack --pack-destination .", { cwd: path });
+  const packResult = execSync3("npm pack --pack-destination .", { cwd: path });
   const [tgzName] = packResult.toString().trim().split("\n");
-  await publish(manifest, await readFile(join(path, tgzName)), {
+  await publish(manifest, await readFile(join2(path, tgzName)), {
     registry,
     defaultTag: "latest",
     forceAuth: {
@@ -191,9 +2208,9 @@ async function emitRemote(spec, options) {
 var typescript_default = command;
 
 // packages/cli/src/lib/cli.ts
-var generate3 = new Command3("generate").addCommand(typescript_default).addCommand(dart_default);
-var cli = program.description(`CLI tool to interact with SDK-IT.`).addCommand(generate3, { isDefault: true }).addCommand(
-  new Command3("_internal").action(() => {
+var generate4 = new Command5("generate").addCommand(typescript_default).addCommand(python_default).addCommand(dart_default).addCommand(apiref_default);
+var cli = program.description(`CLI tool to interact with SDK-IT.`).addCommand(generate4, { isDefault: true }).addCommand(
+  new Command5("_internal").action(() => {
   }),
   { hidden: true }
 ).parse(process.argv);