sdkrouter 0.1.1__py3-none-any.whl

sdkrouter/_api/generated/shortlinks/shortlinks__api__shortlinks/client.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
+class ShortlinksShortlinksAPI:
+    """API endpoints for Shortlinks."""
+
+    def __init__(self, client: httpx.AsyncClient):
+        """Initialize sub-client with shared httpx client."""
+        self._client = client
+
+    async def list(self, page: int | None = None, page_size: int | None = None) -> list[PaginatedShortLinkListList]:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = "/api/shortlinks/"
+        response = await self._client.get(url, params={"page": page if page is not None else None, "page_size": page_size if page_size is not None else None})
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return PaginatedShortLinkListList.model_validate(response.json())
+
+
+    async def create(self, data: ShortLinkCreateRequest) -> ShortLinkCreate:
+        """
+        Create a new short link.
+        """
+        url = "/api/shortlinks/"
+        response = await self._client.post(url, json=data.model_dump(exclude_unset=True))
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkCreate.model_validate(response.json())
+
+
+    async def retrieve(self, code: str) -> ShortLinkDetail:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = await self._client.get(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkDetail.model_validate(response.json())
+
+
+    async def update(self, code: str) -> ShortLinkList:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = await self._client.put(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkList.model_validate(response.json())
+
+
+    async def partial_update(self, code: str) -> ShortLinkList:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = await self._client.patch(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkList.model_validate(response.json())
+
+
+    async def destroy(self, code: str) -> None:
+        """
+        Deactivate a short link.
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = await self._client.delete(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return None
+
+
+    async def stats_retrieve(self) -> ShortLinkStats:
+        """
+        Get shortlink statistics
+
+        Get shortlink statistics for the current user.
+        """
+        url = "/api/shortlinks/stats/"
+        response = await self._client.get(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkStats.model_validate(response.json())
+
+

sdkrouter/_api/generated/shortlinks/shortlinks__api__shortlinks/models.py

@@ -0,0 +1,153 @@
+# Auto-generated by DjangoCFG - see CLAUDE.md
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ShortLinkList(BaseModel):
+    """
+    Serializer for listing short links.
+
+    Response model (includes read-only fields).
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="allow",
+        frozen=False,
+    )
+
+    id: Any = ...
+    code: Any = Field(description='Short code for the URL')
+    custom_slug: Any | None = Field(None, description='Custom slug (optional)')
+    target_url: Any = Field(description='Target URL to redirect to')
+    short_url: Any = ...
+    is_active: bool = Field(description='Whether the link is active')
+    is_expired: bool = ...
+    is_valid: bool = ...
+    hit_count: int = Field(description='Number of times the link was accessed')
+    max_hits: int | None = Field(None, description='Maximum number of redirects (null = unlimited)')
+    expires_at: Any | None = Field(None, description='When the link expires (null = never)')
+    created_at: Any = ...
+
+
+
+class PaginatedShortLinkListList(BaseModel):
+    """
+    
+    Response model (includes read-only fields).
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="allow",
+        frozen=False,
+    )
+
+    count: int = Field(description='Total number of items across all pages')
+    page: int = Field(description='Current page number (1-based)')
+    pages: int = Field(description='Total number of pages')
+    page_size: int = Field(description='Number of items per page')
+    has_next: bool = Field(description='Whether there is a next page')
+    has_previous: bool = Field(description='Whether there is a previous page')
+    next_page: int | None = Field(None, description='Next page number (null if no next page)')
+    previous_page: int | None = Field(None, description='Previous page number (null if no previous page)')
+    results: list[ShortLinkList] = Field(description='Array of items for current page')
+
+
+
+class ShortLinkCreateRequest(BaseModel):
+    """
+    Serializer for creating short links.
+
+    Request model (no read-only fields).
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="allow",
+        frozen=False,
+    )
+
+    target_url: str = Field(min_length=1, max_length=2000)
+    custom_slug: str | None = Field(None, min_length=1, max_length=50)
+    expires_at: str | None = None
+    max_hits: int | None = Field(None, ge=1)
+    metadata: dict[str, Any] | None = None
+
+
+
+class ShortLinkCreate(BaseModel):
+    """
+    Serializer for creating short links.
+
+    Response model (includes read-only fields).
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="allow",
+        frozen=False,
+    )
+
+    target_url: str = Field(max_length=2000)
+    custom_slug: str | None = Field(None, max_length=50)
+    expires_at: str | None = None
+    max_hits: int | None = Field(None, ge=1)
+    metadata: dict[str, Any] | None = None
+
+
+
+class ShortLinkDetail(BaseModel):
+    """
+    Serializer for short link details.
+
+    Response model (includes read-only fields).
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="allow",
+        frozen=False,
+    )
+
+    id: Any = ...
+    code: Any = Field(description='Short code for the URL')
+    custom_slug: Any | None = Field(None, description='Custom slug (optional)')
+    target_url: Any = Field(description='Target URL to redirect to')
+    short_url: Any = ...
+    is_active: bool = Field(description='Whether the link is active')
+    is_expired: bool = ...
+    is_valid: bool = ...
+    hit_count: int = Field(description='Number of times the link was accessed')
+    max_hits: int | None = Field(None, description='Maximum number of redirects (null = unlimited)')
+    expires_at: Any | None = Field(None, description='When the link expires (null = never)')
+    created_at: Any = ...
+    last_hit_at: str | None = Field(None, description='Last time the link was accessed')
+    metadata: dict[str, Any] | None = Field(None, description='Additional metadata (e.g., title, description)')
+    updated_at: Any = ...
+
+
+
+class ShortLinkStats(BaseModel):
+    """
+    Serializer for shortlink statistics.
+
+    Response model (includes read-only fields).
+    """
+
+    model_config = ConfigDict(
+        validate_assignment=True,
+        extra="allow",
+        frozen=False,
+    )
+
+    total_links: int = Field(description='Total number of short links')
+    active_links: int = Field(description='Number of active links')
+    total_hits: int = Field(description='Total hit count across all links')
+
+
+

sdkrouter/_api/generated/shortlinks/shortlinks__api__shortlinks/sync_client.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import httpx
+
+from .models import *
+
+
+class SyncShortlinksShortlinksAPI:
+    """Synchronous API endpoints for Shortlinks."""
+
+    def __init__(self, client: httpx.Client):
+        """Initialize sync sub-client with shared httpx client."""
+        self._client = client
+
+    def list(self, page: int | None = None, page_size: int | None = None) -> list[PaginatedShortLinkListList]:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = "/api/shortlinks/"
+        response = self._client.get(url, params={"page": page if page is not None else None, "page_size": page_size if page_size is not None else None})
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return PaginatedShortLinkListList.model_validate(response.json())
+
+
+    def create(self, data: ShortLinkCreateRequest) -> ShortLinkCreate:
+        """
+        Create a new short link.
+        """
+        url = "/api/shortlinks/"
+        response = self._client.post(url, json=data.model_dump(exclude_unset=True))
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkCreate.model_validate(response.json())
+
+
+    def retrieve(self, code: str) -> ShortLinkDetail:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = self._client.get(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkDetail.model_validate(response.json())
+
+
+    def update(self, code: str) -> ShortLinkList:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = self._client.put(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkList.model_validate(response.json())
+
+
+    def partial_update(self, code: str) -> ShortLinkList:
+        """
+        ViewSet for short link management. Endpoints: - GET /api/shortlinks/ -
+        List user's short links - POST /api/shortlinks/ - Create a new short
+        link - GET /api/shortlinks/{code}/ - Get short link details - DELETE
+        /api/shortlinks/{code}/ - Deactivate short link - GET
+        /api/shortlinks/stats/ - Get link statistics
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = self._client.patch(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkList.model_validate(response.json())
+
+
+    def destroy(self, code: str) -> None:
+        """
+        Deactivate a short link.
+        """
+        url = f"/api/shortlinks/{code}/"
+        response = self._client.delete(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+
+
+    def stats_retrieve(self) -> ShortLinkStats:
+        """
+        Get shortlink statistics
+
+        Get shortlink statistics for the current user.
+        """
+        url = "/api/shortlinks/stats/"
+        response = self._client.get(url)
+        if not response.is_success:
+            try:
+                error_body = response.json()
+            except Exception:
+                error_body = response.text
+            raise httpx.HTTPStatusError(f"{response.status_code}: {error_body}", request=response.request, response=response)
+        return ShortLinkStats.model_validate(response.json())
+
+

sdkrouter/_api/generated/shortlinks/sync_client.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+from typing import Any, Optional
+
+import httpx
+
+from .shortlinks__api__shortlinks.sync_client import SyncShortlinksShortlinksAPI
+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.shortlinks_shortlinks = SyncShortlinksShortlinksAPI(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/vision/__init__.py

@@ -0,0 +1,212 @@
+# 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 .vision__api__vision import VisionVisionAPI
+from . import enums
+# NOTE: Individual enum imports commented out due to invalid Python syntax with dotted names
+# from .enums import OCRRequestRequest.mode, VisionAnalyzeRequestRequest.model_quality
+
+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 vision_vision(self) -> VisionVisionAPI:
+        """Access vision endpoints."""
+        return self._client.vision_vision
+
+    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",
+]