sdkrouter 0.1.1__py3-none-any.whl

sdkrouter/_types/parsed.py

@@ -0,0 +1,101 @@
+"""Parsed chat completion types for structured output."""
+
+from dataclasses import dataclass
+from typing import Any, Generic, Optional, TypeVar
+
+ContentType = TypeVar("ContentType")
+
+
+@dataclass
+class ParsedMessage(Generic[ContentType]):
+    """Message with parsed content from structured output."""
+
+    role: str
+    content: Optional[str] = None
+    parsed: Optional[ContentType] = None
+    refusal: Optional[str] = None
+    tool_calls: Optional[list[Any]] = None
+    function_call: Optional[Any] = None
+
+    @classmethod
+    def from_message(
+        cls,
+        message: Any,
+        parsed_content: Optional[ContentType] = None,
+    ) -> "ParsedMessage[ContentType]":
+        """Create ParsedMessage from raw ChatCompletionMessage."""
+        return cls(
+            role=getattr(message, "role", "assistant"),
+            content=getattr(message, "content", None),
+            parsed=parsed_content,
+            refusal=getattr(message, "refusal", None),
+            tool_calls=getattr(message, "tool_calls", None),
+            function_call=getattr(message, "function_call", None),
+        )
+
+
+@dataclass
+class ParsedChoice(Generic[ContentType]):
+    """Choice with parsed message."""
+
+    index: int
+    message: ParsedMessage[ContentType]
+    finish_reason: Optional[str] = None
+    logprobs: Optional[Any] = None
+
+    @classmethod
+    def from_choice(
+        cls,
+        choice: Any,
+        parsed_content: Optional[ContentType] = None,
+    ) -> "ParsedChoice[ContentType]":
+        """Create ParsedChoice from raw Choice."""
+        return cls(
+            index=getattr(choice, "index", 0),
+            message=ParsedMessage.from_message(
+                getattr(choice, "message", None),
+                parsed_content=parsed_content,
+            ),
+            finish_reason=getattr(choice, "finish_reason", None),
+            logprobs=getattr(choice, "logprobs", None),
+        )
+
+
+@dataclass
+class ParsedChatCompletion(Generic[ContentType]):
+    """ChatCompletion with parsed content from structured output."""
+
+    id: str
+    choices: list[ParsedChoice[ContentType]]
+    created: int
+    model: str
+    object: str = "chat.completion"
+    system_fingerprint: Optional[str] = None
+    usage: Optional[Any] = None
+    service_tier: Optional[str] = None
+
+    @classmethod
+    def from_completion(
+        cls,
+        completion: Any,
+        parsed_choices: list[ParsedChoice[ContentType]],
+    ) -> "ParsedChatCompletion[ContentType]":
+        """Create ParsedChatCompletion from raw ChatCompletion."""
+        return cls(
+            id=getattr(completion, "id", ""),
+            choices=parsed_choices,
+            created=getattr(completion, "created", 0),
+            model=getattr(completion, "model", ""),
+            object=getattr(completion, "object", "chat.completion"),
+            system_fingerprint=getattr(completion, "system_fingerprint", None),
+            usage=getattr(completion, "usage", None),
+            service_tier=getattr(completion, "service_tier", None),
+        )
+
+
+__all__ = [
+    "ContentType",
+    "ParsedMessage",
+    "ParsedChoice",
+    "ParsedChatCompletion",
+]

sdkrouter/_types/shortlinks.py

@@ -0,0 +1,27 @@
+"""Shortlinks types."""
+
+from datetime import datetime
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+
+class ShortLinkCreateRequest(BaseModel):
+    """Request for creating a short link."""
+
+    url: str = Field(description="Target URL to shorten")
+    custom_slug: Optional[str] = Field(default=None, description="Custom short code")
+    ttl: Optional[str] = Field(default=None, description="Time to live")
+    max_hits: Optional[int] = Field(default=None, description="Max redirects allowed")
+
+
+class ShortLink(BaseModel):
+    """Short link information."""
+
+    code: str = Field(description="Short code")
+    short_url: str = Field(description="Full short URL")
+    target_url: str = Field(description="Original target URL")
+    created_at: datetime = Field(description="Creation time")
+    expires_at: Optional[datetime] = Field(default=None, description="Expiration time")
+    hit_count: int = Field(default=0, description="Number of redirects")
+    is_active: bool = Field(default=True, description="Whether link is active")

sdkrouter/_types/vision.py

@@ -0,0 +1,29 @@
+"""Vision types."""
+
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+class VisionAnalyzeRequest(BaseModel):
+    """Request for vision analysis."""
+
+    image: Optional[str] = Field(default=None, description="Base64 encoded image")
+    image_url: Optional[str] = Field(default=None, description="URL of image to analyze")
+    prompt: Optional[str] = Field(default=None, description="Custom analysis prompt")
+    model: Optional[str] = Field(default=None, description="Vision model to use")
+    model_quality: Literal["fast", "balanced", "best"] = Field(
+        default="balanced", description="Quality preset for model selection"
+    )
+    fetch_image: bool = Field(default=True, description="Whether to fetch and store image")
+
+
+class VisionAnalyzeResponse(BaseModel):
+    """Response from vision analysis."""
+
+    extracted_text: str = Field(description="Text extracted from the image")
+    description: str = Field(description="Description of the image content")
+    language: str = Field(description="Detected language")
+    model: str = Field(description="Model used for analysis")
+    cost_usd: float = Field(description="Cost of the analysis in USD")
+    cached: bool = Field(default=False, description="Whether result was from cache")

sdkrouter/_version.py

@@ -0,0 +1,3 @@
+"""Version information."""
+
+__version__ = "0.1.0"

sdkrouter/helpers/__init__.py

@@ -0,0 +1,13 @@
+"""SDK helpers."""
+
+from sdkrouter.helpers.formatting import json_to_toon
+from sdkrouter.helpers.json_cleaner import JsonCleaner
+from sdkrouter.helpers.html import html_to_text, extract_links, extract_images
+
+__all__ = [
+    "json_to_toon",
+    "JsonCleaner",
+    "html_to_text",
+    "extract_links",
+    "extract_images",
+]

sdkrouter/helpers/formatting.py

@@ -0,0 +1,15 @@
+"""JSON formatting utilities."""
+
+from __future__ import annotations
+
+from toon_python import encode as toon_encode
+
+
+def json_to_toon(data: dict | list) -> str:
+    """
+    Convert JSON to TOON format (saves 30-50% tokens).
+
+    Example:
+        {"name": "Alice", "age": 25} → "name: Alice\\nage: 25"
+    """
+    return toon_encode(data)

sdkrouter/helpers/html.py

@@ -0,0 +1,100 @@
+"""HTML utilities for text extraction."""
+
+from __future__ import annotations
+
+from bs4 import BeautifulSoup
+
+
+def html_to_text(html: str, separator: str = "\n") -> str:
+    """
+    Convert HTML to plain text.
+
+    Args:
+        html: HTML string
+        separator: Separator between text blocks (default: newline)
+
+    Returns:
+        Plain text with separator between blocks.
+
+    Usage:
+        text = html_to_text("<div><p>Hello</p><p>World</p></div>")
+        # "Hello\nWorld"
+    """
+    if not html:
+        return ""
+
+    soup = BeautifulSoup(html, "lxml")
+
+    # Remove script and style elements
+    for element in soup(["script", "style", "noscript"]):
+        element.decompose()
+
+    # Get text, handling whitespace
+    text = soup.get_text(separator=separator, strip=True)
+
+    # Clean up multiple separators
+    if separator == "\n":
+        lines = [line.strip() for line in text.split("\n") if line.strip()]
+        return "\n".join(lines)
+
+    return text
+
+
+def extract_links(html: str, base_url: str = "") -> list[dict]:
+    """
+    Extract all links from HTML.
+
+    Args:
+        html: HTML string
+        base_url: Base URL to resolve relative links
+
+    Returns:
+        List of dicts with 'url', 'text' keys.
+    """
+    if not html:
+        return []
+
+    soup = BeautifulSoup(html, "lxml")
+    links = []
+
+    for a in soup.find_all("a", href=True):
+        href = a["href"]
+        if base_url and not href.startswith(("http://", "https://", "//")):
+            href = f"{base_url.rstrip('/')}/{href.lstrip('/')}"
+        elif href.startswith("//"):
+            href = f"https:{href}"
+
+        links.append({
+            "url": href,
+            "text": a.get_text(strip=True),
+        })
+
+    return links
+
+
+def extract_images(html: str, base_url: str = "") -> list[str]:
+    """
+    Extract all image URLs from HTML.
+
+    Args:
+        html: HTML string
+        base_url: Base URL to resolve relative links
+
+    Returns:
+        List of image URLs.
+    """
+    if not html:
+        return []
+
+    soup = BeautifulSoup(html, "lxml")
+    images = []
+
+    for img in soup.find_all("img", src=True):
+        src = img["src"]
+        if base_url and not src.startswith(("http://", "https://", "//")):
+            src = f"{base_url.rstrip('/')}/{src.lstrip('/')}"
+        elif src.startswith("//"):
+            src = f"https:{src}"
+        images.append(src)
+
+    return images

sdkrouter/helpers/json_cleaner.py

@@ -0,0 +1,53 @@
+"""JSON cleaning utilities for LLM consumption."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from toon_python import encode as toon_encode
+
+
+class JsonCleaner:
+    """
+    Clean JSON and convert to TOON format for LLM.
+
+    Usage:
+        cleaner = JsonCleaner(noise_keys={"Photos", "images"})
+        toon_text = cleaner.to_toon(data)
+    """
+
+    DEFAULT_NOISE_KEYS = frozenset({
+        "statusItemTypes",
+        "attributes",
+        "ordering",
+        "updatedDate",
+    })
+
+    def __init__(self, noise_keys: set[str] | None = None):
+        self.noise_keys = self.DEFAULT_NOISE_KEYS | (noise_keys or set())
+
+    def compact(self, data: Any) -> Any:
+        """Remove nulls, empty values, noise keys. Simplify {code,title}->title."""
+        def _process(obj: Any) -> Any:
+            if isinstance(obj, dict):
+                # Simplify {code, title} pattern
+                keys = set(obj.keys())
+                if keys <= {"code", "title", "description"} and "title" in keys:
+                    return obj.get("title") or obj.get("code")
+                # Clean dict
+                result = {}
+                for k, v in obj.items():
+                    if k in self.noise_keys:
+                        continue
+                    cleaned = _process(v)
+                    if cleaned is not None and cleaned != "" and cleaned != [] and cleaned != {}:
+                        result[k] = cleaned
+                return result
+            elif isinstance(obj, list):
+                return [_process(item) for item in obj if _process(item) not in (None, "", [], {})]
+            return obj
+        return _process(data)
+
+    def to_toon(self, data: Any) -> str:
+        """Compact and convert to TOON format."""
+        return toon_encode(self.compact(data))

sdkrouter/tools/__init__.py

@@ -0,0 +1,129 @@
+"""SDK Tools - wrapper resources using generated API clients."""
+
+from .vision import (
+    VisionResource,
+    AsyncVisionResource,
+    VisionAnalyzeRequestRequest,
+    VisionAnalyzeResponse,
+    OCRRequestRequest,
+    OCRResponse,
+    VisionModelsResponse,
+    OCRRequestRequestMode,
+    VisionAnalyzeRequestRequestModelQuality,
+)
+from .cdn import (
+    CDNResource,
+    AsyncCDNResource,
+    CDNUploadResponse,
+    CDNFileList,
+    CDNFileDetail,
+    CDNFileUpload,
+    CDNFileUploadRequest,
+    PaginatedCDNFileListList,
+)
+from .shortlinks import (
+    ShortlinksResource,
+    AsyncShortlinksResource,
+    ShortLinkList,
+    ShortLinkDetail,
+    ShortLinkCreate,
+    ShortLinkCreateRequest,
+    PaginatedShortLinkListList,
+)
+from .keys import (
+    KeysResource,
+    AsyncKeysResource,
+    APIKeyList,
+    APIKeyDetail,
+    APIKeyCreate,
+    APIKeyCreateRequest,
+    PaginatedAPIKeyListList,
+    APIKeyCreatePermission,
+    APIKeyCreateRequestPermission,
+    APIKeyDetailPermission,
+    APIKeyListPermission,
+)
+from .cleaner import (
+    CleanerResource,
+    AsyncCleanerResource,
+    CleanRequestRequest,
+    CleanResponse,
+    CleaningRequestDetail,
+    CleaningStats,
+    CleanRequestRequestOutputFormat,
+    CleaningRequestDetailStatus,
+    CleaningRequestListStatus,
+)
+from .models import (
+    ModelsResource,
+    AsyncModelsResource,
+    LLMModelList,
+    LLMModelDetail,
+    PaginatedLLMModelListList,
+    ProvidersResponse,
+    StatsResponse,
+    CostCalculationRequestRequest,
+    CostCalculationResponse,
+)
+
+__all__ = [
+    # Vision
+    "VisionResource",
+    "AsyncVisionResource",
+    "VisionAnalyzeRequestRequest",
+    "VisionAnalyzeResponse",
+    "OCRRequestRequest",
+    "OCRResponse",
+    "VisionModelsResponse",
+    "OCRRequestRequestMode",
+    "VisionAnalyzeRequestRequestModelQuality",
+    # CDN
+    "CDNResource",
+    "AsyncCDNResource",
+    "CDNUploadResponse",
+    "CDNFileList",
+    "CDNFileDetail",
+    "CDNFileUpload",
+    "CDNFileUploadRequest",
+    "PaginatedCDNFileListList",
+    # Shortlinks
+    "ShortlinksResource",
+    "AsyncShortlinksResource",
+    "ShortLinkList",
+    "ShortLinkDetail",
+    "ShortLinkCreate",
+    "ShortLinkCreateRequest",
+    "PaginatedShortLinkListList",
+    # Keys
+    "KeysResource",
+    "AsyncKeysResource",
+    "APIKeyList",
+    "APIKeyDetail",
+    "APIKeyCreate",
+    "APIKeyCreateRequest",
+    "PaginatedAPIKeyListList",
+    "APIKeyCreatePermission",
+    "APIKeyCreateRequestPermission",
+    "APIKeyDetailPermission",
+    "APIKeyListPermission",
+    # Cleaner
+    "CleanerResource",
+    "AsyncCleanerResource",
+    "CleanRequestRequest",
+    "CleanResponse",
+    "CleaningRequestDetail",
+    "CleaningStats",
+    "CleanRequestRequestOutputFormat",
+    "CleaningRequestDetailStatus",
+    "CleaningRequestListStatus",
+    # Models
+    "ModelsResource",
+    "AsyncModelsResource",
+    "LLMModelList",
+    "LLMModelDetail",
+    "PaginatedLLMModelListList",
+    "ProvidersResponse",
+    "StatsResponse",
+    "CostCalculationRequestRequest",
+    "CostCalculationResponse",
+]