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

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

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

@@ -0,0 +1,165 @@
+"""
+TypeScript Client Generator - Generates TypeScript APIClient classes.
+"""
+
+from __future__ import annotations
+
+from jinja2 import Environment
+from ...ir import IROperationObject
+from ..base import GeneratedFile
+
+class ClientGenerator:
+    """Generates TypeScript APIClient classes (flat and namespaced)."""
+
+    def __init__(self, jinja_env: Environment, context, base, operations_gen):
+        self.jinja_env = jinja_env
+        self.context = context
+        self.base = base
+        self.operations_gen = operations_gen
+
+    def generate_client_file(self):
+        """Generate client.ts with APIClient class."""
+        
+
+        # Client class
+        client_code = self._generate_client_class()
+
+        template = self.jinja_env.get_template('client_file.ts.jinja')
+        content = template.render(
+            has_enums=bool(self.base.get_enum_schemas()),
+            client_code=client_code
+        )
+
+        return GeneratedFile(
+            path="client.ts",
+            content=content,
+            description="APIClient with HTTP adapter and error handling",
+        )
+
+    def _generate_client_class(self) -> str:
+        """Generate APIClient class."""
+        if self.base.client_structure == "namespaced":
+            return self._generate_namespaced_client()
+        else:
+            return self._generate_flat_client()
+
+    def _generate_flat_client(self) -> str:
+        """Generate flat APIClient (all methods in one class)."""
+        # Generate all operation methods
+        method_codes = []
+        for op_id, operation in self.context.operations.items():
+            method_codes.append(self.operations_gen.generate_operation(operation))
+
+        template = self.jinja_env.get_template('client/flat_client.ts.jinja')
+        return template.render(
+            api_title=self.context.openapi_info.title,
+            operations=method_codes
+        )
+
+    def _generate_namespaced_client(self) -> str:
+        """Generate namespaced APIClient (sub-clients per tag)."""
+        # Group operations by tag (using base class method)
+        ops_by_tag = self.base.group_operations_by_tag()
+
+        # Generate sub-client classes
+        sub_client_classes = []
+        for tag, operations in sorted(ops_by_tag.items()):
+            sub_client_classes.append(self._generate_sub_client_class(tag, operations))
+
+        sub_clients_code = "\n\n".join(sub_client_classes)
+
+        # Generate main APIClient
+        main_client_code = self._generate_main_client_class(list(ops_by_tag.keys()))
+
+        return f"{sub_clients_code}\n\n{main_client_code}"
+
+    def _generate_sub_client_class(self, tag: str, operations: list) -> str:
+        """Generate sub-client class for a specific tag."""
+        class_name = self.base.tag_to_class_name(tag)
+
+        # Generate methods for this tag
+        method_codes = []
+        for operation in operations:
+            method_codes.append(self.operations_gen.generate_operation(operation, remove_tag_prefix=True, in_subclient=True))
+
+        template = self.jinja_env.get_template('client/sub_client.ts.jinja')
+        return template.render(
+            tag=self.base.tag_to_display_name(tag),
+            class_name=class_name,
+            operations=method_codes
+        )
+
+    def _generate_main_client_class(self, ops_by_tag: dict) -> str:
+        """Generate main APIClient with sub-clients."""
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare data for template
+        tags_data = [
+            {
+                "class_name": self.base.tag_to_class_name(tag),
+                "property": self.base.tag_to_property_name(tag),
+                "slug": self.base.tag_and_app_to_folder_name(tag, ops_by_tag[tag]),
+            }
+            for tag in tags
+        ]
+
+        template = self.jinja_env.get_template('client/client.ts.jinja')
+        return template.render(
+            sub_clients=True,
+            include_imports=False,  # Imports already in main_client_file.ts.jinja
+            tags=tags_data,
+            info={"title": self.context.openapi_info.title},
+        )
+
+    def generate_main_client_file(self, ops_by_tag: dict):
+        """Generate main client.ts with APIClient."""
+
+        tags = sorted(ops_by_tag.keys())
+
+        # Prepare tags data for template
+        tags_data = [
+            {
+                "class_name": self.base.tag_to_class_name(tag),
+                "slug": self.base.tag_and_app_to_folder_name(tag, ops_by_tag[tag]),
+            }
+            for tag in tags
+        ]
+
+        # Generate main APIClient class
+        client_code = self._generate_main_client_class(ops_by_tag)
+
+        template = self.jinja_env.get_template('client/main_client_file.ts.jinja')
+        content = template.render(
+            tags=tags_data,
+            client_code=client_code
+        )
+
+        return GeneratedFile(
+            path="client.ts",
+            content=content,
+            description="Main API client with HTTP adapter and error handling",
+        )
+
+    def generate_app_client_file(self, tag: str, operations: list[IROperationObject]):
+        """Generate client.ts for a specific app."""
+
+        class_name = self.base.tag_to_class_name(tag)
+
+        # Generate methods
+        method_codes = []
+        for operation in operations:
+            method_codes.append(self.operations_gen.generate_operation(operation, remove_tag_prefix=True, in_subclient=True))
+
+        template = self.jinja_env.get_template('client/app_client.ts.jinja')
+        content = template.render(
+            tag=self.base.tag_to_display_name(tag),
+            class_name=class_name,
+            operations=method_codes
+        )
+
+        folder_name = self.base.tag_and_app_to_folder_name(tag, operations)
+        return GeneratedFile(
+            path=f"{folder_name}/client.ts",
+            content=content,
+            description=f"API client for {tag}",
+        )