sdkrouter 0.1.1__py3-none-any.whl

sdkrouter/tools/cdn.py

@@ -0,0 +1,285 @@
+"""CDN file storage tool using generated API client."""
+
+from pathlib import Path
+from typing import Optional, BinaryIO, Union
+
+import httpx
+
+from .._config import SDKConfig
+from .._api.client import (
+    BaseResource,
+    AsyncBaseResource,
+    SyncCdnCdnAPI,
+    CdnCdnAPI,
+)
+from .._api.generated.cdn.cdn__api__cdn.models import (
+    CDNFileList,
+    CDNFileDetail,
+    CDNFileUpload,
+    CDNFileUploadRequest,
+    PaginatedCDNFileListList,
+    CDNStats,
+)
+
+
+class CDNUploadResponse:
+    """Response from CDN upload - can be immediate result or async job."""
+
+    def __init__(self, data: dict, is_async: bool = False):
+        self._data = data
+        self.is_async = is_async
+
+        if is_async:
+            self.status = data.get("status")
+            self.job_id = data.get("job_id")
+            self.message = data.get("message")
+            self.uuid = None
+            self.filename = None
+            self.url = None
+        else:
+            self.uuid = data.get("uuid")
+            self.filename = data.get("filename")
+            self.url = data.get("url")
+            self.short_url = data.get("short_url")
+            self.content_type = data.get("content_type")
+            self.size_bytes = data.get("size_bytes")
+            self.status = "completed"
+            self.job_id = None
+            self.message = None
+
+    def __repr__(self):
+        if self.is_async:
+            return f"CDNUploadResponse(status={self.status}, job_id={self.job_id})"
+        return f"CDNUploadResponse(uuid={self.uuid}, filename={self.filename})"
+
+
+class CDNResource(BaseResource):
+    """CDN file storage tool (sync).
+
+    Uses generated SyncCdnCdnAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = SyncCdnCdnAPI(self._http_client)
+
+    def upload(
+        self,
+        file: Path | BinaryIO | bytes | None = None,
+        *,
+        url: Optional[str] = None,
+        filename: Optional[str] = None,
+        ttl: Optional[str] = None,
+        is_public: bool = True,
+        metadata: Optional[dict] = None,
+    ) -> Union[CDNFileDetail, CDNUploadResponse]:
+        """
+        Upload a file to CDN.
+
+        Supports two modes:
+        - file: Direct upload from Path, bytes, or file-like object
+        - url: Server downloads from URL (may be processed async)
+
+        Note: File upload requires multipart/form-data, so we use httpx directly.
+        """
+        if not file and not url:
+            raise ValueError("Either 'file' or 'url' must be provided")
+        if file and url:
+            raise ValueError("Provide either 'file' or 'url', not both")
+
+        data = {"is_public": str(is_public).lower()}
+        if ttl:
+            data["ttl"] = ttl
+        if metadata:
+            import json
+            data["metadata"] = json.dumps(metadata)
+
+        if url:
+            # URL mode - use httpx directly since response varies (async job vs file)
+            json_data = {"url": url, "is_public": is_public}
+            if filename is not None:
+                json_data["filename"] = filename
+            if ttl is not None:
+                json_data["ttl"] = ttl
+            if metadata is not None:
+                json_data["metadata"] = metadata
+
+            response = self._http_client.post("/api/cdn/", json=json_data)
+            response.raise_for_status()
+            response_data = response.json()
+
+            # Check if async processing
+            if response.status_code == 202 or "job_id" in response_data or response_data.get("status") == "processing":
+                return CDNUploadResponse(response_data, is_async=True)
+            return CDNFileDetail.model_validate(response_data)
+        else:
+            # File upload mode - use httpx directly (multipart)
+            if isinstance(file, Path):
+                filename = filename or file.name
+                with open(file, "rb") as f:
+                    content = f.read()
+            elif isinstance(file, bytes):
+                content = file
+                if not filename:
+                    raise ValueError("filename required when uploading bytes")
+            else:
+                # BinaryIO
+                content = file.read()
+                filename = filename or getattr(file, "name", "file")
+
+            files = {"file": (filename, content)}
+            response = self._http_client.post("/api/cdn/", files=files, data=data)
+
+            response.raise_for_status()
+            response_data = response.json()
+
+            if response.status_code == 202 or "job_id" in response_data:
+                return CDNUploadResponse(response_data, is_async=True)
+
+            return CDNFileDetail.model_validate(response_data)
+
+    def get(self, uuid: str) -> CDNFileDetail:
+        """Get file details by UUID."""
+        return self._api.retrieve(uuid)
+
+    def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedCDNFileListList:
+        """List files."""
+        return self._api.list(page=page, page_size=page_size)
+
+    def delete(self, uuid: str) -> bool:
+        """Delete a file by UUID."""
+        try:
+            self._api.destroy(uuid)
+            return True
+        except httpx.HTTPStatusError:
+            return False
+
+    def stats(self) -> CDNStats:
+        """Get storage statistics."""
+        return self._api.stats_retrieve()
+
+
+class AsyncCDNResource(AsyncBaseResource):
+    """CDN file storage tool (async).
+
+    Uses generated CdnCdnAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = CdnCdnAPI(self._http_client)
+
+    async def upload(
+        self,
+        file: Path | BinaryIO | bytes | None = None,
+        *,
+        url: Optional[str] = None,
+        filename: Optional[str] = None,
+        ttl: Optional[str] = None,
+        is_public: bool = True,
+        metadata: Optional[dict] = None,
+    ) -> Union[CDNFileDetail, CDNUploadResponse]:
+        """
+        Upload a file to CDN.
+
+        Note: File upload requires multipart/form-data, so we use httpx directly.
+        """
+        if not file and not url:
+            raise ValueError("Either 'file' or 'url' must be provided")
+        if file and url:
+            raise ValueError("Provide either 'file' or 'url', not both")
+
+        data = {"is_public": str(is_public).lower()}
+        if ttl:
+            data["ttl"] = ttl
+        if metadata:
+            import json
+            data["metadata"] = json.dumps(metadata)
+
+        if url:
+            # URL mode - use httpx directly since response varies (async job vs file)
+            json_data = {"url": url, "is_public": is_public}
+            if filename is not None:
+                json_data["filename"] = filename
+            if ttl is not None:
+                json_data["ttl"] = ttl
+            if metadata is not None:
+                json_data["metadata"] = metadata
+
+            response = await self._http_client.post("/api/cdn/", json=json_data)
+            response.raise_for_status()
+            response_data = response.json()
+
+            # Check if async processing
+            if response.status_code == 202 or "job_id" in response_data or response_data.get("status") == "processing":
+                return CDNUploadResponse(response_data, is_async=True)
+            return CDNFileDetail.model_validate(response_data)
+        else:
+            # File upload mode - use httpx directly (multipart)
+            if isinstance(file, Path):
+                filename = filename or file.name
+                with open(file, "rb") as f:
+                    content = f.read()
+            elif isinstance(file, bytes):
+                content = file
+                if not filename:
+                    raise ValueError("filename required when uploading bytes")
+            else:
+                # BinaryIO
+                content = file.read()
+                filename = filename or getattr(file, "name", "file")
+
+            files = {"file": (filename, content)}
+            response = await self._http_client.post("/api/cdn/", files=files, data=data)
+
+            response.raise_for_status()
+            response_data = response.json()
+
+            if response.status_code == 202 or "job_id" in response_data:
+                return CDNUploadResponse(response_data, is_async=True)
+
+            return CDNFileDetail.model_validate(response_data)
+
+    async def get(self, uuid: str) -> CDNFileDetail:
+        """Get file details by UUID."""
+        return await self._api.retrieve(uuid)
+
+    async def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedCDNFileListList:
+        """List files."""
+        return await self._api.list(page=page, page_size=page_size)
+
+    async def delete(self, uuid: str) -> bool:
+        """Delete a file by UUID."""
+        try:
+            await self._api.destroy(uuid)
+            return True
+        except httpx.HTTPStatusError:
+            return False
+
+    async def stats(self) -> CDNStats:
+        """Get storage statistics."""
+        return await self._api.stats_retrieve()
+
+
+__all__ = [
+    "CDNResource",
+    "AsyncCDNResource",
+    "CDNUploadResponse",
+    "CDNStats",
+    # Models
+    "CDNFileList",
+    "CDNFileDetail",
+    "CDNFileUpload",
+    "CDNFileUploadRequest",
+    "PaginatedCDNFileListList",
+]

sdkrouter/tools/cleaner.py

@@ -0,0 +1,186 @@
+"""HTML Cleaner tool using generated API client."""
+
+from pathlib import Path
+from typing import Optional
+
+from .._config import SDKConfig
+from .._api.client import (
+    BaseResource,
+    AsyncBaseResource,
+    SyncCleanerCleanerAPI,
+    CleanerCleanerAPI,
+)
+from .._api.generated.cleaner.cleaner__api__cleaner.models import (
+    CleanRequestRequest,
+    CleanResponse,
+    CleaningRequestDetail,
+    CleaningStats,
+)
+from .._api.generated.cleaner.enums import (
+    CleanRequestRequestOutputFormat,
+    CleaningRequestDetailStatus,
+    CleaningRequestListStatus,
+)
+
+
+class CleanerResource(BaseResource):
+    """HTML Cleaner tool (sync).
+
+    Uses generated SyncCleanerCleanerAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = SyncCleanerCleanerAPI(self._http_client)
+
+    def clean(
+        self,
+        html: bytes | str,
+        *,
+        filename: str = "input.html",
+        output_format: CleanRequestRequestOutputFormat | str = CleanRequestRequestOutputFormat.HTML,
+        max_tokens: int = 10000,
+        remove_scripts: bool = True,
+        remove_styles: bool = True,
+        remove_comments: bool = True,
+        remove_hidden: bool = True,
+        filter_classes: bool = True,
+        class_threshold: float = 0.3,
+        try_hydration: bool = True,
+        preserve_selectors: Optional[list[str]] = None,
+    ) -> CleanResponse:
+        """Clean HTML content via API."""
+        if isinstance(html, str):
+            content = html.encode("utf-8")
+        else:
+            content = html
+
+        # Handle string or enum for output_format
+        format_value = output_format.value if hasattr(output_format, "value") else output_format
+
+        files = {"file": (filename, content, "text/html")}
+        form_data = {
+            "output_format": format_value,
+            "max_tokens": str(max_tokens),
+            "remove_scripts": str(remove_scripts).lower(),
+            "remove_styles": str(remove_styles).lower(),
+            "remove_comments": str(remove_comments).lower(),
+            "remove_hidden": str(remove_hidden).lower(),
+            "filter_classes": str(filter_classes).lower(),
+            "class_threshold": str(class_threshold),
+            "try_hydration": str(try_hydration).lower(),
+        }
+        if preserve_selectors:
+            form_data["preserve_selectors"] = ",".join(preserve_selectors)
+
+        response = self._http_client.post("/api/cleaner/clean/", files=files, data=form_data)
+        response.raise_for_status()
+        return CleanResponse.model_validate(response.json())
+
+    def clean_file(self, file_path: str | Path, **kwargs) -> CleanResponse:
+        """Clean HTML file."""
+        path = Path(file_path)
+        content = path.read_bytes()
+        filename = kwargs.pop("filename", path.name)
+        return self.clean(content, filename=filename, **kwargs)
+
+    def get(self, uuid: str) -> CleaningRequestDetail:
+        """Get cleaning request details."""
+        return self._api.retrieve(uuid)
+
+    def list(self):
+        """List cleaning requests."""
+        return self._api.list()
+
+    def stats(self) -> CleaningStats:
+        """Get cleaning statistics."""
+        return self._api.stats_retrieve()
+
+
+class AsyncCleanerResource(AsyncBaseResource):
+    """HTML Cleaner tool (async).
+
+    Uses generated CleanerCleanerAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = CleanerCleanerAPI(self._http_client)
+
+    async def clean(
+        self,
+        html: bytes | str,
+        *,
+        filename: str = "input.html",
+        output_format: CleanRequestRequestOutputFormat | str = CleanRequestRequestOutputFormat.HTML,
+        max_tokens: int = 10000,
+        remove_scripts: bool = True,
+        remove_styles: bool = True,
+        remove_comments: bool = True,
+        remove_hidden: bool = True,
+        filter_classes: bool = True,
+        class_threshold: float = 0.3,
+        try_hydration: bool = True,
+        preserve_selectors: Optional[list[str]] = None,
+    ) -> CleanResponse:
+        """Clean HTML content via API."""
+        if isinstance(html, str):
+            content = html.encode("utf-8")
+        else:
+            content = html
+
+        # Handle string or enum for output_format
+        format_value = output_format.value if hasattr(output_format, "value") else output_format
+
+        files = {"file": (filename, content, "text/html")}
+        form_data = {
+            "output_format": format_value,
+            "max_tokens": str(max_tokens),
+            "remove_scripts": str(remove_scripts).lower(),
+            "remove_styles": str(remove_styles).lower(),
+            "remove_comments": str(remove_comments).lower(),
+            "remove_hidden": str(remove_hidden).lower(),
+            "filter_classes": str(filter_classes).lower(),
+            "class_threshold": str(class_threshold),
+            "try_hydration": str(try_hydration).lower(),
+        }
+        if preserve_selectors:
+            form_data["preserve_selectors"] = ",".join(preserve_selectors)
+
+        response = await self._http_client.post("/api/cleaner/clean/", files=files, data=form_data)
+        response.raise_for_status()
+        return CleanResponse.model_validate(response.json())
+
+    async def clean_file(self, file_path: str | Path, **kwargs) -> CleanResponse:
+        """Clean HTML file."""
+        path = Path(file_path)
+        content = path.read_bytes()
+        filename = kwargs.pop("filename", path.name)
+        return await self.clean(content, filename=filename, **kwargs)
+
+    async def get(self, uuid: str) -> CleaningRequestDetail:
+        """Get cleaning request details."""
+        return await self._api.retrieve(uuid)
+
+    async def list(self):
+        """List cleaning requests."""
+        return await self._api.list()
+
+    async def stats(self) -> CleaningStats:
+        """Get cleaning statistics."""
+        return await self._api.stats_retrieve()
+
+
+__all__ = [
+    "CleanerResource",
+    "AsyncCleanerResource",
+    # Models
+    "CleanRequestRequest",
+    "CleanResponse",
+    "CleaningRequestDetail",
+    "CleaningStats",
+    # Enums
+    "CleanRequestRequestOutputFormat",
+    "CleaningRequestDetailStatus",
+    "CleaningRequestListStatus",
+]

sdkrouter/tools/keys.py

@@ -0,0 +1,215 @@
+"""API Keys management tool using generated API client."""
+
+from datetime import datetime
+from decimal import Decimal
+from typing import Optional
+
+from .._config import SDKConfig
+from .._api.client import (
+    BaseResource,
+    AsyncBaseResource,
+    SyncKeysKeysAPI,
+    KeysKeysAPI,
+)
+from .._api.generated.keys.keys__api__keys.models import (
+    APIKeyList,
+    APIKeyDetail,
+    APIKeyCreate,
+    APIKeyCreateRequest,
+    PaginatedAPIKeyListList,
+)
+from .._api.generated.keys.enums import (
+    APIKeyCreatePermission,
+    APIKeyCreateRequestPermission,
+    APIKeyDetailPermission,
+    APIKeyListPermission,
+)
+
+
+class KeysResource(BaseResource):
+    """API Keys management tool (sync).
+
+    Uses generated SyncKeysKeysAPI client.
+
+    Example:
+        ```python
+        from sdkrouter import SDKRouter
+
+        client = SDKRouter(api_key="your-api-key")
+
+        # Create a new key
+        new_key = client.keys.create(name="Production Key")
+        print(f"New key: {new_key.plain_key}")  # Save this!
+
+        # List all keys
+        keys = client.keys.list()
+        for key in keys.results:
+            print(f"{key.name}: {key.key_prefix}...")
+
+        # Rotate a key
+        rotated = client.keys.rotate(key_id)
+        print(f"New rotated key: {rotated.plain_key}")
+        ```
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = SyncKeysKeysAPI(self._http_client)
+
+    def create(
+        self,
+        name: str,
+        *,
+        permission: APIKeyCreateRequestPermission = APIKeyCreateRequestPermission.WRITE,
+        rate_limit_rpm: Optional[int] = None,
+        rate_limit_rpd: Optional[int] = None,
+        quota_monthly_usd: Optional[Decimal] = None,
+        expires_at: Optional[datetime] = None,
+        metadata: Optional[dict] = None,
+        is_test: bool = False,
+    ) -> APIKeyCreate:
+        """
+        Create a new API key.
+
+        Args:
+            name: Human-readable name for the key
+            permission: Permission level (read, write, admin)
+            rate_limit_rpm: Max requests per minute (None = unlimited)
+            rate_limit_rpd: Max requests per day (None = unlimited)
+            quota_monthly_usd: Monthly spending limit in USD
+            expires_at: When the key expires
+            metadata: Additional metadata
+            is_test: Create a test key (sk_test_ prefix)
+
+        Returns:
+            APIKeyCreate with key info including `plain_key` (only shown once!)
+        """
+        request = APIKeyCreateRequest(
+            name=name,
+            permission=permission,
+            rate_limit_rpm=rate_limit_rpm,
+            rate_limit_rpd=rate_limit_rpd,
+            quota_monthly_usd=str(quota_monthly_usd) if quota_monthly_usd else None,
+            expires_at=expires_at.isoformat() if expires_at else None,
+            metadata=metadata,
+            is_test=is_test,
+        )
+        return self._api.create(request)
+
+    def get(self, key_id: str) -> APIKeyDetail:
+        """Get API key details by ID."""
+        return self._api.retrieve(key_id)
+
+    def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedAPIKeyListList:
+        """List your API keys."""
+        return self._api.list(page=page, page_size=page_size)
+
+    def delete(self, key_id: str) -> bool:
+        """Deactivate an API key (soft delete)."""
+        try:
+            self._api.destroy(key_id)
+            return True
+        except httpx.HTTPStatusError:
+            return False
+
+    def rotate(self, key_id: str) -> APIKeyList:
+        """
+        Rotate an API key (generate new key).
+
+        The old key will stop working immediately.
+
+        Returns:
+            APIKeyList with `plain_key` (the new key - only shown once!)
+        """
+        return self._api.rotate_create(key_id)
+
+    def reactivate(self, key_id: str) -> APIKeyList:
+        """Reactivate a deactivated API key."""
+        return self._api.reactivate_create(key_id)
+
+
+class AsyncKeysResource(AsyncBaseResource):
+    """API Keys management tool (async).
+
+    Uses generated KeysKeysAPI client.
+    """
+
+    def __init__(self, config: SDKConfig):
+        super().__init__(config)
+        self._api = KeysKeysAPI(self._http_client)
+
+    async def create(
+        self,
+        name: str,
+        *,
+        permission: APIKeyCreateRequestPermission = APIKeyCreateRequestPermission.WRITE,
+        rate_limit_rpm: Optional[int] = None,
+        rate_limit_rpd: Optional[int] = None,
+        quota_monthly_usd: Optional[Decimal] = None,
+        expires_at: Optional[datetime] = None,
+        metadata: Optional[dict] = None,
+        is_test: bool = False,
+    ) -> APIKeyCreate:
+        """Create a new API key."""
+        request = APIKeyCreateRequest(
+            name=name,
+            permission=permission,
+            rate_limit_rpm=rate_limit_rpm,
+            rate_limit_rpd=rate_limit_rpd,
+            quota_monthly_usd=str(quota_monthly_usd) if quota_monthly_usd else None,
+            expires_at=expires_at.isoformat() if expires_at else None,
+            metadata=metadata,
+            is_test=is_test,
+        )
+        return await self._api.create(request)
+
+    async def get(self, key_id: str) -> APIKeyDetail:
+        """Get API key details by ID."""
+        return await self._api.retrieve(key_id)
+
+    async def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> PaginatedAPIKeyListList:
+        """List your API keys."""
+        return await self._api.list(page=page, page_size=page_size)
+
+    async def delete(self, key_id: str) -> bool:
+        """Deactivate an API key (soft delete)."""
+        try:
+            await self._api.destroy(key_id)
+            return True
+        except httpx.HTTPStatusError:
+            return False
+
+    async def rotate(self, key_id: str) -> APIKeyList:
+        """Rotate an API key (generate new key)."""
+        return await self._api.rotate_create(key_id)
+
+    async def reactivate(self, key_id: str) -> APIKeyList:
+        """Reactivate a deactivated API key."""
+        return await self._api.reactivate_create(key_id)
+
+
+__all__ = [
+    "KeysResource",
+    "AsyncKeysResource",
+    # Models
+    "APIKeyList",
+    "APIKeyDetail",
+    "APIKeyCreate",
+    "APIKeyCreateRequest",
+    "PaginatedAPIKeyListList",
+    # Enums
+    "APIKeyCreatePermission",
+    "APIKeyCreateRequestPermission",
+    "APIKeyDetailPermission",
+    "APIKeyListPermission",
+]