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

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

@@ -6,24 +6,42 @@ class API:
     - Thread-safe JWT token storage
     - Automatic Authorization header injection
     - Context manager support for async operations
+    - Optional retry and logging configuration
 
     Example:
         >>> api = API('https://api.example.com')
         >>> api.set_token('jwt-token')
         >>> async with api:
         ...     users = await api.users.list()
+        >>>
+        >>> # With retry and logging
+        >>> api = API(
+        ...     'https://api.example.com',
+        ...     retry_config=RetryConfig(max_attempts=5),
+        ...     logger_config=LoggerConfig(enabled=True)
+        ... )
     """
 
-    def __init__(self, base_url: str, **kwargs: Any):
+    def __init__(
+        self,
+        base_url: str,
+        logger_config: LoggerConfig | None = None,
+        retry_config: RetryConfig | None = 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)
+            retry_config: Retry configuration (None to disable retry)
             **kwargs: Additional httpx.AsyncClient kwargs
         """
         self.base_url = base_url.rstrip('/')
         self._kwargs = kwargs
+        self._logger_config = logger_config
+        self._retry_config = retry_config
         self._token: str | None = None
         self._refresh_token: str | None = None
         self._lock = threading.Lock()
@@ -42,7 +60,12 @@ class API:
             kwargs['headers'] = headers
 
         # Create new APIClient
-        self._client = APIClient(self.base_url, **kwargs)
+        self._client = APIClient(
+            self.base_url,
+            logger_config=self._logger_config,
+            retry_config=self._retry_config,
+            **kwargs
+        )
 
 {% for prop in properties %}
     @property

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

@@ -6,12 +6,18 @@ class APIClient:
         >>> async with APIClient(base_url='https://api.example.com') as client:
         ...     users = await client.users.list()
         ...     post = await client.posts.create(data=new_post)
+        >>>
+        >>> # With retry configuration
+        >>> retry_config = RetryConfig(max_attempts=5, min_wait=2.0)
+        >>> async with APIClient(base_url='https://api.example.com', retry_config=retry_config) as client:
+        ...     users = await client.users.list()
     """
 
     def __init__(
         self,
         base_url: str,
         logger_config: Optional[LoggerConfig] = None,
+        retry_config: Optional[RetryConfig] = None,
         **kwargs: Any,
     ):
         """
@@ -20,14 +26,25 @@ class APIClient:
         Args:
             base_url: Base API URL (e.g., 'https://api.example.com')
             logger_config: Logger configuration (None to disable logging)
+            retry_config: Retry configuration (None to disable retry)
             **kwargs: Additional httpx.AsyncClient kwargs
         """
         self.base_url = base_url.rstrip('/')
-        self._client = httpx.AsyncClient(
-            base_url=self.base_url,
-            timeout=30.0,
-            **kwargs,
-        )
+
+        # Create HTTP client with or without retry
+        if retry_config is not None:
+            self._client = RetryAsyncClient(
+                base_url=self.base_url,
+                retry_config=retry_config,
+                timeout=30.0,
+                **kwargs,
+            )
+        else:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                timeout=30.0,
+                **kwargs,
+            )
 
         # Initialize logger
         self.logger: Optional[APILogger] = None
@@ -40,10 +57,11 @@ class APIClient:
 {% endfor %}
 
     async def __aenter__(self) -> 'APIClient':
+        await self._client.__aenter__()
         return self
 
     async def __aexit__(self, *args: Any) -> None:
-        await self._client.aclose()
+        await self._client.__aexit__(*args)
 
     async def close(self) -> None:
         """Close HTTP client."""

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

@@ -8,6 +8,7 @@ import httpx
 from .{{ tag.slug }} import {{ tag.class_name }}
 {% endfor %}
 from .logger import APILogger, LoggerConfig
+from .retry import RetryConfig, RetryAsyncClient
 
 
 {{ client_code }}

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

@@ -1,6 +1,8 @@
 async def {{ method_name }}({{ params | join(', ') }}) -> {{ return_type }}:
 {% if docstring %}
-    """{{ docstring }}"""
+    """
+{{ docstring | indent(4, first=True) }}
+    """
 {% endif %}
 {% for line in body_lines %}
     {{ line }}

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

@@ -1,3 +1,10 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
 class {{ class_name }}:
     """API endpoints for {{ tag }}."""
 
@@ -6,6 +13,6 @@ class {{ class_name }}:
         self._client = client
 
 {% for operation in operations %}
-    {{ operation }}
+{{ operation | indent(4, first=True) }}
 
 {% endfor %}

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

@@ -0,0 +1,50 @@
+class SyncAPIClient:
+    """
+    Synchronous API client for {{ api_title }}.
+
+    Usage:
+        >>> with SyncAPIClient(base_url='https://api.example.com') as client:
+        ...     users = client.users.list()
+        ...     post = client.posts.create(data=new_post)
+    """
+
+    def __init__(
+        self,
+        base_url: str,
+        logger_config: Optional[LoggerConfig] = None,
+        **kwargs: Any,
+    ):
+        """
+        Initialize sync 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.Client kwargs
+        """
+        self.base_url = base_url.rstrip('/')
+        self._client = httpx.Client(
+            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 }} = Sync{{ tag.class_name }}(self._client)
+{% endfor %}
+
+    def __enter__(self) -> 'SyncAPIClient':
+        return self
+
+    def __exit__(self, *args: Any) -> None:
+        self._client.close()
+
+    def close(self) -> None:
+        """Close HTTP client."""
+        self._client.close()

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

@@ -0,0 +1,9 @@
+def {{ method_name }}({{ params | join(', ') }}) -> {{ return_type }}:
+{% if docstring %}
+    """
+{{ docstring | indent(4, first=True) }}
+    """
+{% endif %}
+{% for line in body_lines %}
+    {{ line }}
+{% endfor %}

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

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
+class Sync{{ class_name }}:
+    """Synchronous API endpoints for {{ tag }}."""
+
+    def __init__(self, client: httpx.Client):
+        """Initialize sync 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 → python/templates}/main_init.py.jinja

@@ -31,6 +31,8 @@ import httpx
 
 from .client import APIClient
 from .schema import OPENAPI_SCHEMA
+from .logger import LoggerConfig
+from .retry import RetryConfig
 {% for tag in tags %}
 from .{{ tag.slug }} import {{ tag.class_name }}
 {% endfor %}

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

@@ -1,6 +1,8 @@
 class {{ name }}({{ base_class }}):
 {% if docstring %}
-    """{{ docstring }}"""
+    """
+{{ docstring | indent(4, first=True) }}
+    """
 {% endif %}
 {% if members %}
 {% if docstring %}

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

@@ -1,6 +1,8 @@
 class {{ name }}(BaseModel):
 {% if docstring %}
-    """{{ docstring }}"""
+    """
+{{ docstring | indent(4, first=True) }}
+    """
 {% endif %}
 
     model_config = ConfigDict(

django_cfg/modules/django_client/core/generator/python/templates/pyproject.toml.jinja

@@ -0,0 +1,55 @@
+[tool.poetry]
+name = "{{ package_name }}"
+version = "{{ version }}"
+description = "{{ description }}"
+authors = {{ authors | tojson }}
+license = "{{ license }}"
+readme = "README.md"
+{% if repository_url %}repository = "{{ repository_url }}"
+{% endif %}keywords = {{ keywords | tojson }}
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Typing :: Typed",
+]
+
+[tool.poetry.dependencies]
+python = "{{ python_version }}"
+pydantic = "^2.12"
+httpx = "^0.28"
+tenacity = "^9.1"
+rich = "^14.1.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0"
+pytest-asyncio = "^0.24"
+pytest-cov = "^6.0"
+mypy = "^1.18"
+ruff = "^0.13"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.mypy]
+python_version = "3.12"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+
+[tool.ruff]
+line-length = 100
+target-version = "py312"
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "N", "UP", "B"]
+ignore = []
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+addopts = "--cov={{ package_name | replace('-', '_') }} --cov-report=html --cov-report=term"

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/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']