django-cfg 1.4.9__py3-none-any.whl → 1.4.11__py3-none-any.whl

django_cfg/modules/django_client/core/generator/templates/python/__init__.py.jinja

@@ -0,0 +1,9 @@
+from .client import APIClient
+from .models import *
+{% if has_enums %}
+from .enums import *
+{% endif %}
+
+__all__ = [
+    "APIClient",
+]

django_cfg/modules/django_client/core/generator/templates/python/api_wrapper.py.jinja

@@ -0,0 +1,130 @@
+class API:
+    """
+    API Client wrapper with JWT token management.
+
+    This class provides:
+    - Thread-safe JWT token storage
+    - Automatic Authorization header injection
+    - Context manager support for async operations
+
+    Example:
+        >>> api = API('https://api.example.com')
+        >>> api.set_token('jwt-token')
+        >>> async with api:
+        ...     users = await api.users.list()
+    """
+
+    def __init__(self, base_url: str, **kwargs: Any):
+        """
+        Initialize API client.
+
+        Args:
+            base_url: Base API URL (e.g., 'https://api.example.com')
+            **kwargs: Additional httpx.AsyncClient kwargs
+        """
+        self.base_url = base_url.rstrip('/')
+        self._kwargs = kwargs
+        self._token: str | None = None
+        self._refresh_token: str | None = None
+        self._lock = threading.Lock()
+        self._client: APIClient | None = None
+        self._init_clients()
+
+    def _init_clients(self) -> None:
+        """Initialize API client with current token."""
+        # Create httpx client with auth header if token exists
+        headers = {}
+        if self._token:
+            headers['Authorization'] = f'Bearer {self._token}'
+
+        kwargs = {**self._kwargs}
+        if headers:
+            kwargs['headers'] = headers
+
+        # Create new APIClient
+        self._client = APIClient(self.base_url, **kwargs)
+
+{% for prop in properties %}
+    @property
+    def {{ prop.property }}(self) -> {{ prop.class_name }}:
+        """Access {{ prop.tag }} endpoints."""
+        return self._client.{{ prop.property }}
+
+{% endfor %}
+    def get_token(self) -> str | None:
+        """Get current JWT token."""
+        with self._lock:
+            return self._token
+
+    def get_refresh_token(self) -> str | None:
+        """Get current refresh token."""
+        with self._lock:
+            return self._refresh_token
+
+    def set_token(self, token: str, refresh_token: str | None = None) -> None:
+        """
+        Set JWT token and refresh token.
+
+        Args:
+            token: JWT access token
+            refresh_token: JWT refresh token (optional)
+        """
+        with self._lock:
+            self._token = token
+            if refresh_token:
+                self._refresh_token = refresh_token
+
+        # Reinitialize clients with new token
+        self._init_clients()
+
+    def clear_tokens(self) -> None:
+        """Clear all tokens."""
+        with self._lock:
+            self._token = None
+            self._refresh_token = None
+
+        # Reinitialize clients without token
+        self._init_clients()
+
+    def is_authenticated(self) -> bool:
+        """Check if user is authenticated."""
+        return self.get_token() is not None
+
+    def set_base_url(self, url: str) -> None:
+        """
+        Update base URL and reinitialize clients.
+
+        Args:
+            url: New base URL
+        """
+        self.base_url = url.rstrip('/')
+        self._init_clients()
+
+    def get_base_url(self) -> str:
+        """Get current base URL."""
+        return self.base_url
+
+    def get_schema(self) -> dict[str, Any]:
+        """
+        Get OpenAPI schema.
+
+        Returns:
+            Complete OpenAPI specification for this API
+        """
+        return OPENAPI_SCHEMA
+
+    async def __aenter__(self) -> 'API':
+        """Async context manager entry."""
+        if self._client:
+            await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        """Async context manager exit."""
+        if self._client:
+            await self._client.__aexit__(*args)
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        if self._client:
+            await self._client.close()

django_cfg/modules/django_client/core/generator/templates/python/app_init.py.jinja

@@ -0,0 +1,6 @@
+from .client import {{ class_name }}
+from .models import *
+
+__all__ = [
+    "{{ class_name }}",
+]

django_cfg/modules/django_client/core/generator/templates/python/client/app_client.py.jinja

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
+class {{ class_name }}:
+    """API endpoints for {{ tag }}."""
+
+    def __init__(self, client: httpx.AsyncClient):
+        """Initialize sub-client with shared httpx client."""
+        self._client = client
+
+{% for operation in operations %}
+{{ operation | indent(4, first=True) }}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/client/flat_client.py.jinja

@@ -0,0 +1,38 @@
+class APIClient:
+    """
+    Async API client for {{ api_title }}.
+
+    Usage:
+        >>> async with APIClient(base_url='https://api.example.com') as client:
+        ...     users = await client.users_list()
+    """
+
+    def __init__(self, base_url: str, **kwargs: Any):
+        """
+        Initialize API client.
+
+        Args:
+            base_url: Base API URL (e.g., 'https://api.example.com')
+            **kwargs: Additional httpx.AsyncClient kwargs
+        """
+        self.base_url = base_url.rstrip('/')
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=30.0,
+            **kwargs,
+        )
+
+    async def __aenter__(self) -> 'APIClient':
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self._client.aclose()
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        await self._client.aclose()
+
+{% for operation in operations %}
+    {{ operation }}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/client/main_client.py.jinja

@@ -0,0 +1,50 @@
+class APIClient:
+    """
+    Async API client for {{ api_title }}.
+
+    Usage:
+        >>> async with APIClient(base_url='https://api.example.com') as client:
+        ...     users = await client.users.list()
+        ...     post = await client.posts.create(data=new_post)
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        logger_config: Optional[LoggerConfig] = None,
+        **kwargs: Any,
+    ):
+        """
+        Initialize API client.
+
+        Args:
+            base_url: Base API URL (e.g., 'https://api.example.com')
+            logger_config: Logger configuration (None to disable logging)
+            **kwargs: Additional httpx.AsyncClient kwargs
+        """
+        self.base_url = base_url.rstrip('/')
+        self._client = httpx.AsyncClient(
+            base_url=self.base_url,
+            timeout=30.0,
+            **kwargs,
+        )
+
+        # Initialize logger
+        self.logger: Optional[APILogger] = None
+        if logger_config is not None:
+            self.logger = APILogger(logger_config)
+
+        # Initialize sub-clients
+{% for tag in tags %}
+        self.{{ tag.property }} = {{ tag.class_name }}(self._client)
+{% endfor %}
+
+    async def __aenter__(self) -> 'APIClient':
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self._client.aclose()
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        await self._client.aclose()

django_cfg/modules/django_client/core/generator/templates/python/client/main_client_file.py.jinja

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+{% for tag in tags %}
+from .{{ tag.slug }} import {{ tag.class_name }}
+{% endfor %}
+from .logger import APILogger, LoggerConfig
+
+
+{{ client_code }}

django_cfg/modules/django_client/core/generator/templates/python/client/operation_method.py.jinja

@@ -0,0 +1,7 @@
+async def {{ method_name }}({{ params | join(', ') }}) -> {{ return_type }}:
+{% if docstring %}
+    """{{ docstring }}"""
+{% endif %}
+{% for line in body_lines %}
+    {{ line }}
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/client/sub_client.py.jinja

@@ -0,0 +1,11 @@
+class {{ class_name }}:
+    """API endpoints for {{ tag }}."""
+
+    def __init__(self, client: httpx.AsyncClient):
+        """Initialize sub-client with shared httpx client."""
+        self._client = client
+
+{% for operation in operations %}
+    {{ operation }}
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/client_file.py.jinja

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import Any
+
+import httpx
+
+from .models import *
+{% if has_enums %}
+from .enums import *
+{% endif %}
+
+
+{{ client_code }}

django_cfg/modules/django_client/core/generator/templates/python/main_init.py.jinja

@@ -0,0 +1,50 @@
+"""
+{{ api_title }} - API Client with JWT Management
+
+Usage:
+    >>> from api import API
+    >>>
+    >>> api = API('https://api.example.com')
+    >>>
+    >>> # Set JWT token
+    >>> api.set_token('your-jwt-token', 'refresh-token')
+    >>>
+    >>> # Use API
+    >>> async with api:
+    ...     posts = await api.posts.list()
+    ...     user = await api.users.retrieve(1)
+    >>>
+    >>> # Check authentication
+    >>> if api.is_authenticated():
+    ...     # ...
+    >>>
+    >>> # Get OpenAPI schema
+    >>> schema = api.get_schema()
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+import httpx
+
+from .client import APIClient
+from .schema import OPENAPI_SCHEMA
+{% for tag in tags %}
+from .{{ tag.slug }} import {{ tag.class_name }}
+{% endfor %}
+{% if has_enums %}
+from . import enums
+from .enums import {{ enum_names | join(', ') }}
+{% endif %}
+
+TOKEN_KEY = "auth_token"
+REFRESH_TOKEN_KEY = "refresh_token"
+
+{{ api_class }}
+
+__all__ = [
+    "API",
+    "APIClient",
+]

django_cfg/modules/django_client/core/generator/templates/python/models/app_models.py.jinja

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+{% if has_enums and enum_names %}
+
+from ..enums import {{ enum_names | join(', ') }}
+{% endif %}
+
+
+{% for schema in schemas %}
+{{ schema }}
+
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/models/enum_class.py.jinja

@@ -0,0 +1,15 @@
+class {{ name }}({{ base_class }}):
+{% if docstring %}
+    """{{ docstring }}"""
+{% endif %}
+{% if members %}
+{% if docstring %}
+
+{% endif %}
+{% for member in members %}
+    {{ member }}
+{% endfor %}
+{% else %}
+
+    pass
+{% endif %}

django_cfg/modules/django_client/core/generator/templates/python/models/enums.py.jinja

@@ -0,0 +1,8 @@
+from enum import IntEnum, StrEnum
+
+
+{% for enum in enums %}
+{{ enum }}
+
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/models/models.py.jinja

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+{% if has_enums %}
+
+from .enums import *
+{% endif %}
+
+
+{% for schema in schemas %}
+{{ schema }}
+
+
+{% endfor %}

django_cfg/modules/django_client/core/generator/templates/python/models/schema_class.py.jinja

@@ -0,0 +1,19 @@
+class {{ name }}(BaseModel):
+{% if docstring %}
+    """{{ docstring }}"""
+{% endif %}
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="forbid",
+        frozen=False,
+    )
+{% if fields %}
+
+{% for field in fields %}
+    {{ field }}
+{% endfor %}
+{% else %}
+
+    pass
+{% endif %}

django_cfg/modules/django_client/core/generator/templates/python/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()