django-cfg 1.4.10__py3-none-any.whl → 1.4.13__py3-none-any.whl

django_cfg/modules/django_client/core/generator/python/templates/utils/logger.py.jinja

@@ -0,0 +1,255 @@
+"""
+API Logger with Rich
+Beautiful console logging for API requests and responses
+
+Installation:
+    pip install rich
+"""
+
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+
+@dataclass
+class RequestLog:
+    """Request log data."""
+
+    method: str
+    url: str
+    headers: Optional[Dict[str, str]] = None
+    body: Optional[Any] = None
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ResponseLog:
+    """Response log data."""
+
+    status: int
+    status_text: str
+    data: Optional[Any] = None
+    duration: float = 0.0
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class ErrorLog:
+    """Error log data."""
+
+    message: str
+    status_code: Optional[int] = None
+    field_errors: Optional[Dict[str, list[str]]] = None
+    duration: float = 0.0
+    timestamp: float = field(default_factory=time.time)
+
+
+@dataclass
+class LoggerConfig:
+    """Logger configuration."""
+
+    enabled: bool = True
+    log_requests: bool = True
+    log_responses: bool = True
+    log_errors: bool = True
+    log_bodies: bool = True
+    log_headers: bool = False
+    console: Optional[Console] = None
+
+
+# Sensitive header names to filter out
+SENSITIVE_HEADERS = [
+    "authorization",
+    "cookie",
+    "set-cookie",
+    "x-api-key",
+    "x-csrf-token",
+]
+
+
+class APILogger:
+    """API Logger class."""
+
+    def __init__(self, config: Optional[LoggerConfig] = None):
+        """Initialize logger."""
+        self.config = config or LoggerConfig()
+        self.console = self.config.console or Console()
+
+    def enable(self) -> None:
+        """Enable logging."""
+        self.config.enabled = True
+
+    def disable(self) -> None:
+        """Disable logging."""
+        self.config.enabled = False
+
+    def set_config(self, **kwargs: Any) -> None:
+        """Update configuration."""
+        for key, value in kwargs.items():
+            if hasattr(self.config, key):
+                setattr(self.config, key, value)
+
+    def _filter_headers(self, headers: Optional[Dict[str, str]]) -> Dict[str, str]:
+        """Filter sensitive headers."""
+        if not headers:
+            return {}
+
+        filtered = {}
+        for key, value in headers.items():
+            if key.lower() in SENSITIVE_HEADERS:
+                filtered[key] = "***"
+            else:
+                filtered[key] = value
+
+        return filtered
+
+    def log_request(self, request: RequestLog) -> None:
+        """Log request."""
+        if not self.config.enabled or not self.config.log_requests:
+            return
+
+        # Create request info
+        text = Text()
+        text.append("→ ", style="bold blue")
+        text.append(request.method, style="bold yellow")
+        text.append(" ", style="")
+        text.append(request.url, style="cyan")
+
+        self.console.print(text)
+
+        if self.config.log_headers and request.headers:
+            headers = self._filter_headers(request.headers)
+            self.console.print("  Headers:", style="dim")
+            for key, value in headers.items():
+                self.console.print(f"    {key}: {value}", style="dim")
+
+        if self.config.log_bodies and request.body:
+            self.console.print("  Body:", style="dim")
+            self.console.print(request.body, style="dim")
+
+    def log_response(self, request: RequestLog, response: ResponseLog) -> None:
+        """Log response."""
+        if not self.config.enabled or not self.config.log_responses:
+            return
+
+        # Determine color based on status
+        if response.status >= 500:
+            status_style = "bold red"
+        elif response.status >= 400:
+            status_style = "bold yellow"
+        elif response.status >= 300:
+            status_style = "bold cyan"
+        else:
+            status_style = "bold green"
+
+        # Create response info
+        text = Text()
+        text.append("← ", style="bold green")
+        text.append(request.method, style="bold yellow")
+        text.append(" ", style="")
+        text.append(request.url, style="cyan")
+        text.append(" ", style="")
+        text.append(str(response.status), style=status_style)
+        text.append(" ", style="")
+        text.append(response.status_text, style=status_style)
+        text.append(f" ({response.duration:.0f}ms)", style="dim")
+
+        self.console.print(text)
+
+        if self.config.log_bodies and response.data:
+            self.console.print("  Response:", style="dim")
+            self.console.print(response.data, style="dim")
+
+    def log_error(self, request: RequestLog, error: ErrorLog) -> None:
+        """Log error."""
+        if not self.config.enabled or not self.config.log_errors:
+            return
+
+        # Create error header
+        text = Text()
+        text.append("✗ ", style="bold red")
+        text.append(request.method, style="bold yellow")
+        text.append(" ", style="")
+        text.append(request.url, style="cyan")
+        text.append(" ", style="")
+        text.append(
+            str(error.status_code) if error.status_code else "Network",
+            style="bold red",
+        )
+        text.append(" Error", style="bold red")
+        text.append(f" ({error.duration:.0f}ms)", style="dim")
+
+        self.console.print(text)
+        self.console.print(f"  Message: {error.message}", style="red")
+
+        if error.field_errors:
+            self.console.print("  Field Errors:", style="red")
+            for field, errors in error.field_errors.items():
+                for err in errors:
+                    self.console.print(f"    • {field}: {err}", style="red dim")
+
+    def info(self, message: str, **kwargs: Any) -> None:
+        """Log info message."""
+        if not self.config.enabled:
+            return
+        self.console.print(f"ℹ {message}", style="blue", **kwargs)
+
+    def warn(self, message: str, **kwargs: Any) -> None:
+        """Log warning message."""
+        if not self.config.enabled:
+            return
+        self.console.print(f"⚠ {message}", style="yellow", **kwargs)
+
+    def error(self, message: str, **kwargs: Any) -> None:
+        """Log error message."""
+        if not self.config.enabled:
+            return
+        self.console.print(f"✗ {message}", style="red", **kwargs)
+
+    def success(self, message: str, **kwargs: Any) -> None:
+        """Log success message."""
+        if not self.config.enabled:
+            return
+        self.console.print(f"✓ {message}", style="green", **kwargs)
+
+    def debug(self, message: str, **kwargs: Any) -> None:
+        """Log debug message."""
+        if not self.config.enabled:
+            return
+        self.console.print(f"🔍 {message}", style="dim", **kwargs)
+
+    def panel(self, content: Any, title: str, style: str = "blue") -> None:
+        """Log content in a panel."""
+        if not self.config.enabled:
+            return
+        self.console.print(Panel(content, title=title, border_style=style))
+
+    def table(
+        self,
+        headers: list[str],
+        rows: list[list[Any]],
+        title: Optional[str] = None,
+    ) -> None:
+        """Log data in a table."""
+        if not self.config.enabled:
+            return
+
+        table = Table(title=title)
+        for header in headers:
+            table.add_column(header, style="cyan")
+
+        for row in rows:
+            table.add_row(*[str(cell) for cell in row])
+
+        self.console.print(table)
+
+
+# Default logger instance
+default_logger = APILogger()

django_cfg/modules/django_client/core/generator/python/templates/utils/retry.py.jinja

@@ -0,0 +1,271 @@
+"""
+Retry Configuration and Utilities
+
+Provides automatic retry logic for failed HTTP requests using tenacity.
+Retries only on network errors and server errors (5xx), not client errors (4xx).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Callable, Any
+import httpx
+from tenacity import (
+    retry,
+    stop_after_attempt,
+    wait_exponential,
+    retry_if_exception,
+    RetryCallState,
+    before_sleep_log,
+)
+import logging
+
+
+@dataclass
+class RetryConfig:
+    """
+    Retry configuration options.
+
+    Uses exponential backoff with jitter by default to avoid thundering herd.
+    """
+
+    max_attempts: int = 3
+    """Maximum number of retry attempts (default: 3)"""
+
+    min_wait: float = 1.0
+    """Minimum wait time between retries in seconds (default: 1.0)"""
+
+    max_wait: float = 60.0
+    """Maximum wait time between retries in seconds (default: 60.0)"""
+
+    multiplier: float = 2.0
+    """Exponential backoff multiplier (default: 2.0)"""
+
+    on_retry: Callable[[RetryCallState], None] | None = None
+    """Callback called on each retry attempt"""
+
+    logger: logging.Logger | None = None
+    """Logger for retry attempts (default: None)"""
+
+
+DEFAULT_RETRY_CONFIG = RetryConfig()
+"""Default retry configuration"""
+
+
+def should_retry(exception: BaseException) -> bool:
+    """
+    Determine if an error should trigger a retry.
+
+    Retries on:
+    - Network errors (connection refused, timeout, etc.)
+    - Server errors (5xx status codes)
+    - Rate limiting (429 status code)
+
+    Does NOT retry on:
+    - Client errors (4xx except 429)
+    - Authentication errors (401, 403)
+    - Not found (404)
+
+    Args:
+        exception: The exception to check
+
+    Returns:
+        True if should retry, False otherwise
+    """
+    # Always retry network errors
+    if isinstance(exception, (
+        httpx.NetworkError,
+        httpx.TimeoutException,
+        httpx.ConnectError,
+        httpx.ReadError,
+        httpx.WriteError,
+        httpx.PoolTimeout,
+    )):
+        return True
+
+    # For HTTP errors, check status code
+    if isinstance(exception, httpx.HTTPStatusError):
+        status = exception.response.status_code
+
+        # Retry on 5xx server errors
+        if 500 <= status < 600:
+            return True
+
+        # Retry on 429 (rate limit)
+        if status == 429:
+            return True
+
+        # Do NOT retry on 4xx client errors
+        return False
+
+    # Don't retry on unknown errors
+    return False
+
+
+def create_retry_decorator(config: RetryConfig | None = None):
+    """
+    Create a retry decorator with the given configuration.
+
+    Args:
+        config: Retry configuration (uses defaults if None)
+
+    Returns:
+        Tenacity retry decorator
+
+    Example:
+        >>> retry_decorator = create_retry_decorator(RetryConfig(max_attempts=5))
+        >>> @retry_decorator
+        ... async def fetch_data():
+        ...     async with httpx.AsyncClient() as client:
+        ...         response = await client.get('https://api.example.com/users')
+        ...         response.raise_for_status()
+        ...         return response.json()
+    """
+    cfg = config or DEFAULT_RETRY_CONFIG
+
+    # Build retry decorator
+    retry_args = {
+        'stop': stop_after_attempt(cfg.max_attempts),
+        'wait': wait_exponential(
+            multiplier=cfg.multiplier,
+            min=cfg.min_wait,
+            max=cfg.max_wait,
+        ),
+        'retry': retry_if_exception(should_retry),
+        'reraise': True,
+    }
+
+    # Add logger if provided
+    if cfg.logger:
+        retry_args['before_sleep'] = before_sleep_log(cfg.logger, logging.WARNING)
+
+    # Add custom callback if provided
+    if cfg.on_retry:
+        original_before_sleep = retry_args.get('before_sleep')
+
+        def combined_before_sleep(retry_state: RetryCallState):
+            if original_before_sleep:
+                original_before_sleep(retry_state)
+            if cfg.on_retry:
+                cfg.on_retry(retry_state)
+
+        retry_args['before_sleep'] = combined_before_sleep
+
+    return retry(**retry_args)
+
+
+async def with_retry(
+    fn: Callable[..., Any],
+    config: RetryConfig | None = None,
+    *args,
+    **kwargs
+) -> Any:
+    """
+    Execute an async function with retry logic.
+
+    Args:
+        fn: Async function to retry
+        config: Retry configuration (uses defaults if None)
+        *args: Positional arguments for fn
+        **kwargs: Keyword arguments for fn
+
+    Returns:
+        Result of the function
+
+    Example:
+        >>> async def fetch_users():
+        ...     async with httpx.AsyncClient() as client:
+        ...         response = await client.get('https://api.example.com/users')
+        ...         response.raise_for_status()
+        ...         return response.json()
+        >>>
+        >>> result = await with_retry(fetch_users, RetryConfig(max_attempts=5))
+    """
+    retry_decorator = create_retry_decorator(config)
+    retryable_fn = retry_decorator(fn)
+    return await retryable_fn(*args, **kwargs)
+
+
+class RetryAsyncClient:
+    """
+    HTTP client wrapper that adds automatic retry logic.
+
+    Wraps httpx.AsyncClient and applies retry logic to all HTTP methods.
+    Transparently retries on network errors, 5xx status codes, and 429 rate limits.
+
+    Example:
+        >>> async with RetryAsyncClient('https://api.example.com', retry_config=RetryConfig(max_attempts=5)) as client:
+        ...     response = await client.get('/users')
+        ...     response.raise_for_status()
+    """
+
+    def __init__(
+        self,
+        base_url: str | None = None,
+        retry_config: RetryConfig | None = None,
+        **kwargs: Any
+    ):
+        """
+        Initialize retry-enabled HTTP client.
+
+        Args:
+            base_url: Base URL for all requests
+            retry_config: Retry configuration (None to disable retry)
+            **kwargs: Additional httpx.AsyncClient kwargs
+        """
+        self._client = httpx.AsyncClient(base_url=base_url, **kwargs)
+        self.retry_config = retry_config
+        self._retry_decorator = create_retry_decorator(retry_config) if retry_config else None
+
+    async def __aenter__(self) -> 'RetryAsyncClient':
+        await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self._client.__aexit__(*args)
+
+    async def aclose(self) -> None:
+        """Close the HTTP client."""
+        await self._client.aclose()
+
+    def _wrap_with_retry(self, method: str):
+        """Wrap HTTP method with retry logic."""
+        original_method = getattr(self._client, method)
+
+        if self._retry_decorator:
+            async def wrapped(*args, **kwargs):
+                @self._retry_decorator
+                async def _do_request():
+                    return await original_method(*args, **kwargs)
+                return await _do_request()
+            return wrapped
+        else:
+            return original_method
+
+    async def get(self, *args, **kwargs) -> httpx.Response:
+        """GET request with retry."""
+        return await self._wrap_with_retry('get')(*args, **kwargs)
+
+    async def post(self, *args, **kwargs) -> httpx.Response:
+        """POST request with retry."""
+        return await self._wrap_with_retry('post')(*args, **kwargs)
+
+    async def put(self, *args, **kwargs) -> httpx.Response:
+        """PUT request with retry."""
+        return await self._wrap_with_retry('put')(*args, **kwargs)
+
+    async def patch(self, *args, **kwargs) -> httpx.Response:
+        """PATCH request with retry."""
+        return await self._wrap_with_retry('patch')(*args, **kwargs)
+
+    async def delete(self, *args, **kwargs) -> httpx.Response:
+        """DELETE request with retry."""
+        return await self._wrap_with_retry('delete')(*args, **kwargs)
+
+    async def head(self, *args, **kwargs) -> httpx.Response:
+        """HEAD request with retry."""
+        return await self._wrap_with_retry('head')(*args, **kwargs)
+
+    async def options(self, *args, **kwargs) -> httpx.Response:
+        """OPTIONS request with retry."""
+        return await self._wrap_with_retry('options')(*args, **kwargs)

django_cfg/modules/django_client/core/generator/python/templates/utils/schema.py.jinja

@@ -0,0 +1,12 @@
+"""
+OpenAPI Schema
+
+This file contains the complete OpenAPI specification for this API.
+It can be used for documentation, validation, or code generation.
+"""
+
+from typing import Any, Dict
+
+OPENAPI_SCHEMA: Dict[str, Any] = {{ schema_dict }}
+
+__all__ = ["OPENAPI_SCHEMA"]

django_cfg/modules/django_client/core/generator/typescript/__init__.py

@@ -0,0 +1,14 @@
+"""
+TypeScript Generator - Generates TypeScript client (Fetch API).
+
+This generator creates a complete TypeScript API client from IR:
+- TypeScript interfaces (Request/Response/Patch splits)
+- Enum types from x-enum-varnames
+- Fetch API for HTTP
+- Django CSRF/session handling
+- Type-safe
+"""
+
+from .generator import TypeScriptGenerator
+
+__all__ = ['TypeScriptGenerator']