sdkrouter 0.1.1__py3-none-any.whl

sdkrouter/_api/generated/models/pyproject.toml

@@ -0,0 +1,55 @@
+# Auto-generated by DjangoCFG - see CLAUDE.md
+[tool.poetry]
+name = "api-client"
+version = "1.0.0"
+description = "Auto-generated Python client for SDKRouter API"
+authors = ["Author \u003cauthor@example.com\u003e"]
+license = "MIT"
+readme = "README.md"
+keywords = ["api", "client", "python", "openapi"]
+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 = "^3.12"
+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=api_client --cov-report=html --cov-report=term"

sdkrouter/_api/generated/models/retry.py

@@ -0,0 +1,272 @@
+# Auto-generated by DjangoCFG - see CLAUDE.md
+"""
+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)

sdkrouter/_api/generated/models/sync_client.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+from .models__api__llm_models.sync_client import SyncModelsLlmModelsAPI
+from .logger import APILogger, LoggerConfig
+from .retry import RetryConfig, RetryAsyncClient
+
+
+class SyncAPIClient:
+    """
+    Synchronous API client for SDKRouter API.
+
+    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,
+            **kwargs,
+        )
+
+        # Initialize logger
+        self.logger: Optional[APILogger] = None
+        if logger_config is not None:
+            self.logger = APILogger(logger_config)
+
+        # Initialize sub-clients
+        self.models_llm_models = SyncModelsLlmModelsAPI(self._client)
+
+    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()

sdkrouter/_api/generated/shortlinks/__init__.py

@@ -0,0 +1,209 @@
+# Auto-generated by DjangoCFG - see CLAUDE.md
+"""
+SDKRouter API - 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 path
+    >>> schema_path = api.get_schema_path()
+"""
+
+from __future__ import annotations
+
+import threading
+from typing import Any
+
+import httpx
+
+from .client import APIClient
+from .logger import LoggerConfig
+from .retry import RetryConfig
+from .shortlinks__api__shortlinks import ShortlinksShortlinksAPI
+
+TOKEN_KEY = "auth_token"
+REFRESH_TOKEN_KEY = "refresh_token"
+
+# Auto-generated by DjangoCFG - see CLAUDE.md
+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
+    - 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,
+        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()
+        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,
+            logger_config=self._logger_config,
+            retry_config=self._retry_config,
+            **kwargs
+        )
+
+    @property
+    def shortlinks_shortlinks(self) -> ShortlinksShortlinksAPI:
+        """Access shortlinks endpoints."""
+        return self._client.shortlinks_shortlinks
+
+    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_path(self) -> str:
+        """
+        Get OpenAPI schema path.
+
+        Returns:
+            Path to the OpenAPI schema JSON file
+
+        Note:
+            The OpenAPI schema is available in the schema.json file.
+            You can load it dynamically using:
+            ```python
+            import json
+            from pathlib import Path
+
+            schema_path = Path(__file__).parent / 'schema.json'
+            with open(schema_path) as f:
+                schema = json.load(f)
+            ```
+        """
+        return './schema.json'
+
+    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()
+
+__all__ = [
+    "API",
+    "APIClient",
+]

sdkrouter/_api/generated/shortlinks/client.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+from .shortlinks__api__shortlinks import ShortlinksShortlinksAPI
+from .logger import APILogger, LoggerConfig
+from .retry import RetryConfig, RetryAsyncClient
+
+
+class APIClient:
+    """
+    Async API client for SDKRouter API.
+
+    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)
+        >>>
+        >>> # 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,
+    ):
+        """
+        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('/')
+
+        # 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,
+                **kwargs,
+            )
+        else:
+            self._client = httpx.AsyncClient(
+                base_url=self.base_url,
+                **kwargs,
+            )
+
+        # Initialize logger
+        self.logger: Optional[APILogger] = None
+        if logger_config is not None:
+            self.logger = APILogger(logger_config)
+
+        # Initialize sub-clients
+        self.shortlinks_shortlinks = ShortlinksShortlinksAPI(self._client)
+
+    async def __aenter__(self) -> 'APIClient':
+        await self._client.__aenter__()
+        return self
+
+    async def __aexit__(self, *args: Any) -> None:
+        await self._client.__aexit__(*args)
+
+    async def close(self) -> None:
+        """Close HTTP client."""
+        await self._client.aclose()