sdkrouter 0.1.1__py3-none-any.whl

sdkrouter/__init__.py

@@ -0,0 +1,110 @@
+"""
+SDKRouter - Unified SDK for AI services with OpenAI compatibility.
+
+Example:
+    ```python
+    from sdkrouter import SDKRouter
+
+    # Initialize client
+    client = SDKRouter(api_key="your-api-key")
+
+    # OpenAI-compatible chat
+    response = client.chat.completions.create(
+        model="openai/gpt-4o",
+        messages=[{"role": "user", "content": "Hello!"}],
+    )
+    print(response.choices[0].message.content)
+
+    # Vision analysis
+    result = client.vision.analyze(image_url="https://example.com/image.jpg")
+    print(result.description)
+
+    # CDN upload
+    from pathlib import Path
+    file = client.cdn.upload(Path("image.png"), ttl="7d")
+    print(file.url)
+    ```
+"""
+
+from ._version import __version__
+from ._client import SDKRouter, AsyncSDKRouter
+from ._config import SDKConfig, get_config, configure, reset_config
+
+# API Client utilities
+from ._api import HTTPClientFactory, BaseResource, AsyncBaseResource
+
+# Types
+from ._types.vision import VisionAnalyzeRequest, VisionAnalyzeResponse
+from ._types.ocr import OCRRequest, OCRResponse
+from ._types.cdn import CDNFile, CDNUploadRequest
+from ._types.shortlinks import ShortLink, ShortLinkCreateRequest
+from ._types.models import Model, ModelPricing
+from ._types.parsed import ParsedChatCompletion, ParsedChoice, ParsedMessage
+
+# Helpers (from archive)
+from .helpers import json_to_toon, JsonCleaner, html_to_text, extract_links, extract_images
+
+# Utilities
+from .utils import (
+    TokenCounter,
+    count_tokens,
+    count_messages_tokens,
+    estimate_image_tokens,
+    get_optimal_detail_mode,
+    # Parsing utilities
+    ResponseFormatT,
+    to_strict_json_schema,
+    type_to_response_format,
+)
+
+__all__ = [
+    # Version
+    "__version__",
+    # Clients
+    "SDKRouter",
+    "AsyncSDKRouter",
+    # Configuration
+    "SDKConfig",
+    "get_config",
+    "configure",
+    "reset_config",
+    # API utilities
+    "HTTPClientFactory",
+    "BaseResource",
+    "AsyncBaseResource",
+    # Vision types
+    "VisionAnalyzeRequest",
+    "VisionAnalyzeResponse",
+    # OCR types
+    "OCRRequest",
+    "OCRResponse",
+    # CDN types
+    "CDNFile",
+    "CDNUploadRequest",
+    # Shortlinks types
+    "ShortLink",
+    "ShortLinkCreateRequest",
+    # Model types
+    "Model",
+    "ModelPricing",
+    # Parsed types (structured output)
+    "ParsedChatCompletion",
+    "ParsedChoice",
+    "ParsedMessage",
+    # Helpers
+    "json_to_toon",
+    "JsonCleaner",
+    "html_to_text",
+    "extract_links",
+    "extract_images",
+    # Token utilities
+    "TokenCounter",
+    "count_tokens",
+    "count_messages_tokens",
+    "estimate_image_tokens",
+    "get_optimal_detail_mode",
+    # Parsing utilities
+    "ResponseFormatT",
+    "to_strict_json_schema",
+    "type_to_response_format",
+]

sdkrouter/_api/__init__.py

@@ -0,0 +1,28 @@
+"""
+SDKRouter API Client Utilities.
+
+Provides base classes for building tool resources:
+- HTTPClientFactory: Creates configured httpx clients
+- BaseResource: Base class for sync tool resources
+- AsyncBaseResource: Base class for async tool resources
+
+Usage:
+    >>> from sdkrouter._api import BaseResource, AsyncBaseResource
+    >>>
+    >>> class MyResource(BaseResource):
+    ...     def __init__(self, config):
+    ...         super().__init__(config)
+    ...         self._api = SyncMyAPI(self._http_client)
+"""
+
+from .client import (
+    HTTPClientFactory,
+    BaseResource,
+    AsyncBaseResource,
+)
+
+__all__ = [
+    "HTTPClientFactory",
+    "BaseResource",
+    "AsyncBaseResource",
+]

sdkrouter/_api/client.py

@@ -0,0 +1,204 @@
+"""
+SDKRouter API Client Utilities.
+
+Provides:
+- HTTPClientFactory: Creates configured httpx clients
+- BaseResource: Base class for sync tool resources
+- AsyncBaseResource: Base class for async tool resources
+- Generated API clients (sync and async) for all tools
+
+All tools inherit from base classes to ensure consistent
+HTTP client configuration and authentication.
+
+Example:
+    >>> from sdkrouter._api.client import BaseResource, SyncVisionVisionAPI
+    >>>
+    >>> class VisionResource(BaseResource):
+    ...     def __init__(self, config):
+    ...         super().__init__(config)
+    ...         self._api = SyncVisionVisionAPI(self._http_client)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import httpx
+
+if TYPE_CHECKING:
+    from .._config import SDKConfig
+
+# ============================================================================
+# Generated API Clients (Async)
+# ============================================================================
+from .generated.vision.vision__api__vision import VisionVisionAPI
+from .generated.cdn.cdn__api__cdn import CdnCdnAPI
+from .generated.keys.keys__api__keys import KeysKeysAPI
+from .generated.shortlinks.shortlinks__api__shortlinks import ShortlinksShortlinksAPI
+from .generated.cleaner.cleaner__api__cleaner import CleanerCleanerAPI
+from .generated.models.models__api__llm_models import ModelsLlmModelsAPI
+
+# ============================================================================
+# Generated API Clients (Sync)
+# ============================================================================
+from .generated.vision.vision__api__vision.sync_client import SyncVisionVisionAPI
+from .generated.cdn.cdn__api__cdn.sync_client import SyncCdnCdnAPI
+from .generated.keys.keys__api__keys.sync_client import SyncKeysKeysAPI
+from .generated.shortlinks.shortlinks__api__shortlinks.sync_client import SyncShortlinksShortlinksAPI
+from .generated.cleaner.cleaner__api__cleaner.sync_client import SyncCleanerCleanerAPI
+from .generated.models.models__api__llm_models.sync_client import SyncModelsLlmModelsAPI
+
+
+class HTTPClientFactory:
+    """
+    Factory for creating configured httpx clients.
+
+    Creates sync/async HTTP clients with:
+    - Base URL from config
+    - Bearer token authentication
+    - Configured timeout
+
+    Example:
+        >>> factory = HTTPClientFactory(sdk_config)
+        >>> sync_client = factory.create_sync_client()
+        >>> async_client = factory.create_async_client()
+    """
+
+    def __init__(self, config: "SDKConfig"):
+        """
+        Initialize factory with SDK configuration.
+
+        Args:
+            config: SDKConfig with base_url, api_key, timeout
+        """
+        self._config = config
+
+    def _get_headers(self) -> dict[str, str]:
+        """Build request headers with auth token."""
+        return {"Authorization": f"Bearer {self._config.api_key}"}
+
+    def create_sync_client(self) -> httpx.Client:
+        """
+        Create a synchronous HTTP client.
+
+        Returns:
+            Configured httpx.Client with base_url, auth headers, timeout
+        """
+        return httpx.Client(
+            base_url=self._config.base_url,
+            headers=self._get_headers(),
+            timeout=self._config.timeout,
+        )
+
+    def create_async_client(self) -> httpx.AsyncClient:
+        """
+        Create an asynchronous HTTP client.
+
+        Returns:
+            Configured httpx.AsyncClient with base_url, auth headers, timeout
+        """
+        return httpx.AsyncClient(
+            base_url=self._config.base_url,
+            headers=self._get_headers(),
+            timeout=self._config.timeout,
+        )
+
+
+class BaseResource:
+    """
+    Base class for synchronous tool resources.
+
+    Provides:
+    - HTTP client creation via HTTPClientFactory
+    - Access to SDK config
+    - Common http_client property
+
+    Subclasses should initialize their generated API client in __init__:
+
+        class VisionResource(BaseResource):
+            def __init__(self, config: SDKConfig):
+                super().__init__(config)
+                self._api = SyncVisionVisionAPI(self._http_client)
+    """
+
+    def __init__(self, config: "SDKConfig"):
+        """
+        Initialize resource with SDK configuration.
+
+        Args:
+            config: SDKConfig with base_url, api_key, timeout
+        """
+        self._config = config
+        self._factory = HTTPClientFactory(config)
+        self._http_client = self._factory.create_sync_client()
+
+    @property
+    def http_client(self) -> httpx.Client:
+        """Access the underlying HTTP client for direct requests."""
+        return self._http_client
+
+    @property
+    def config(self) -> "SDKConfig":
+        """Access the SDK configuration."""
+        return self._config
+
+
+class AsyncBaseResource:
+    """
+    Base class for asynchronous tool resources.
+
+    Provides:
+    - HTTP client creation via HTTPClientFactory
+    - Access to SDK config
+    - Common http_client property
+
+    Subclasses should initialize their generated API client in __init__:
+
+        class AsyncVisionResource(AsyncBaseResource):
+            def __init__(self, config: SDKConfig):
+                super().__init__(config)
+                self._api = VisionVisionAPI(self._http_client)
+    """
+
+    def __init__(self, config: "SDKConfig"):
+        """
+        Initialize resource with SDK configuration.
+
+        Args:
+            config: SDKConfig with base_url, api_key, timeout
+        """
+        self._config = config
+        self._factory = HTTPClientFactory(config)
+        self._http_client = self._factory.create_async_client()
+
+    @property
+    def http_client(self) -> httpx.AsyncClient:
+        """Access the underlying HTTP client for direct requests."""
+        return self._http_client
+
+    @property
+    def config(self) -> "SDKConfig":
+        """Access the SDK configuration."""
+        return self._config
+
+
+__all__ = [
+    # Base classes
+    "HTTPClientFactory",
+    "BaseResource",
+    "AsyncBaseResource",
+    # Async clients
+    "VisionVisionAPI",
+    "CdnCdnAPI",
+    "KeysKeysAPI",
+    "ShortlinksShortlinksAPI",
+    "CleanerCleanerAPI",
+    "ModelsLlmModelsAPI",
+    # Sync clients
+    "SyncVisionVisionAPI",
+    "SyncCdnCdnAPI",
+    "SyncKeysKeysAPI",
+    "SyncShortlinksShortlinksAPI",
+    "SyncCleanerCleanerAPI",
+    "SyncModelsLlmModelsAPI",
+]

sdkrouter/_api/generated/__init__.py

@@ -0,0 +1,21 @@
+"""
+Auto-generated OpenAPI clients for SDK.
+
+DO NOT EDIT - Generated by: python manage.py generate_api_sdk
+"""
+
+from . import vision
+from . import models
+from . import cdn
+from . import shortlinks
+from . import keys
+from . import cleaner
+
+__all__ = [
+    "vision",
+    "models",
+    "cdn",
+    "shortlinks",
+    "keys",
+    "cleaner",
+]

sdkrouter/_api/generated/cdn/__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 .cdn__api__cdn import CdnCdnAPI
+
+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 cdn_cdn(self) -> CdnCdnAPI:
+        """Access cdn endpoints."""
+        return self._client.cdn_cdn
+
+    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/cdn/cdn__api__cdn/__init__.py

@@ -0,0 +1,7 @@
+# Auto-generated by DjangoCFG - see CLAUDE.md
+from .client import CdnCdnAPI
+from .models import *
+
+__all__ = [
+    "CdnCdnAPI",
+]