turboapi-sdk 0.1.0__py3-none-any.whl

turboapi/__init__.py

@@ -0,0 +1,56 @@
+"""
+TurboAPI SDK - Call AI services through the TurboAPI platform.
+
+Usage:
+    from turboapi import TurboAPIClient
+
+    client = TurboAPIClient(api_key="tbp_xxxxx")
+
+    # Create a task and wait for result
+    result = client.call.create_and_wait(
+        slug_id="karaoke-maker",
+        input={"audio_file": "https://..."},
+        timeout=300,
+    )
+    print(result.output)
+"""
+
+from turboapi.client import TurboAPIClient
+from turboapi.models import (
+    APIListData,
+    APIResponse,
+    CategoryResponse,
+    TaskResponse,
+    TaskLogItem,
+    TaskListResponse,
+    TaskStatus,
+    TaskPriority,
+)
+from turboapi.errors import (
+    TurboAPIError,
+    AuthenticationError,
+    RateLimitError,
+    TaskError,
+    NotFoundError,
+    ValidationError,
+)
+
+__all__ = [
+    "TurboAPIClient",
+    # Models
+    "APIListData",
+    "APIResponse",
+    "CategoryResponse",
+    "TaskResponse",
+    "TaskLogItem",
+    "TaskListResponse",
+    "TaskStatus",
+    "TaskPriority",
+    # Errors
+    "TurboAPIError",
+    "AuthenticationError",
+    "RateLimitError",
+    "TaskError",
+    "NotFoundError",
+    "ValidationError",
+]

turboapi/client.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import time
+from typing import Any, Dict, Optional
+
+import httpx
+
+from turboapi.errors import (
+    TurboAPIError,
+    NetworkError,
+    TimeoutError,
+)
+from turboapi.models import (
+    APIListData,
+    APIResponse,
+    CategoryResponse,
+    TaskListResponse,
+    TaskResponse,
+    TaskStatus,
+)
+
+DEFAULT_BASE_URL = "https://api.turboapi.ai/api/v1"
+DEFAULT_TIMEOUT = 30.0
+DEFAULT_POLL_INTERVAL = 2.0
+DEFAULT_POLL_TIMEOUT = 300.0
+
+
+class _CallModule:
+    """Task creation and management."""
+
+    def __init__(self, client: "TurboAPIClient"):
+        self._client = client
+
+    def create(
+        self,
+        slug_id: str,
+        input: Dict[str, Any],
+        *,
+        prefer_wait: bool = False,
+    ) -> TaskResponse:
+        """Submit a task for execution.
+
+        Args:
+            slug_id: The API slug identifier (e.g. 'karaoke-maker').
+            input: Input parameters for the API.
+            prefer_wait: If True, server will attempt synchronous execution.
+
+        Returns:
+            A TaskResponse with task_id and initial status.
+        """
+        body: Dict[str, Any] = {"slug_id": slug_id, "input": input}
+        headers = {}
+        if prefer_wait:
+            headers["Prefer-Wait"] = "wait"
+
+        data = self._client._request("POST", "/call", json=body, headers=headers)
+        return TaskResponse.from_dict(data)
+
+    def get(self, task_id: str) -> TaskResponse:
+        """Get the current status and details of a task.
+
+        Args:
+            task_id: The task ID returned from create().
+
+        Returns:
+            Current TaskResponse with status and optional output.
+        """
+        data = self._client._request("GET", f"/call/{task_id}")
+        return TaskResponse.from_dict(data)
+
+    def cancel(self, task_id: str) -> None:
+        """Request cancellation of a queued task.
+
+        Args:
+            task_id: The task ID to cancel.
+
+        Raises:
+            NotFoundError: If the task doesn't exist.
+            TaskError: If the task cannot be cancelled (already running/complete).
+        """
+        self._client._request("POST", f"/call/{task_id}/cancel")
+
+    def create_and_wait(
+        self,
+        slug_id: str,
+        input: Dict[str, Any],
+        *,
+        timeout: float = DEFAULT_POLL_TIMEOUT,
+        poll_interval: float = DEFAULT_POLL_INTERVAL,
+    ) -> TaskResponse:
+        """Submit a task and block until it completes or fails.
+
+        This is a convenience method that:
+        1. Creates the task via create()
+        2. Polls get() until status is terminal
+        3. Returns the final result
+
+        Args:
+            slug_id: The API slug identifier.
+            input: Input parameters for the API.
+            timeout: Maximum total wait time in seconds.
+            poll_interval: Seconds between status checks.
+
+        Returns:
+            Final TaskResponse with output on success.
+
+        Raises:
+            TimeoutError: If the task doesn't complete within timeout.
+        """
+        task = self.create(slug_id, input)
+
+        deadline = time.monotonic() + timeout
+        while time.monotonic() < deadline:
+            task = self.get(task.task_id)
+
+            if task.status and task.status.is_terminal:
+                return task
+
+            remaining = deadline - time.monotonic()
+            sleep = min(poll_interval, remaining)
+            if sleep <= 0:
+                break
+            time.sleep(sleep)
+
+        raise TimeoutError(
+            f"Task {task.task_id} did not complete within {timeout}s",
+            error_code="TIMEOUT",
+            details={
+                "task_id": task.task_id,
+                "last_status": task.status.value if task.status else "unknown",
+            },
+        )
+
+
+class _TasksModule:
+    """Task listing and querying for the authenticated user."""
+
+    def __init__(self, client: "TurboAPIClient"):
+        self._client = client
+
+    def list(
+        self,
+        *,
+        status: Optional[TaskStatus] = None,
+        api_slug: Optional[str] = None,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> TaskListResponse:
+        """List tasks for the authenticated user.
+
+        Args:
+            status: Filter by task status.
+            api_slug: Filter by API slug.
+            page: Page number (1-indexed).
+            page_size: Items per page (max 100).
+
+        Returns:
+            A paginated list of TaskResponse items.
+        """
+        params: Dict[str, Any] = {"page": page, "page_size": page_size}
+        if status:
+            params["status"] = status.value
+        if api_slug:
+            params["api_slug"] = api_slug
+
+        data = self._client._request("GET", "/tasks", params=params)
+        return TaskListResponse.from_dict(data)
+
+    def get(self, task_id: str) -> TaskResponse:
+        """Get a specific task's detail.
+
+        Args:
+            task_id: The task ID.
+
+        Returns:
+            Full TaskResponse for the given task.
+        """
+        data = self._client._request("GET", f"/tasks/{task_id}")
+        return TaskResponse.from_dict(data)
+
+    def logs(
+        self,
+        task_id: str,
+        *,
+        page: int = 1,
+        page_size: int = 50,
+    ) -> Dict[str, Any]:
+        """Get execution logs for a task.
+
+        Args:
+            task_id: The task ID.
+            page: Page number (1-indexed).
+            page_size: Items per page (max 100).
+
+        Returns:
+            Raw response data containing log items.
+        """
+        params: Dict[str, Any] = {"page": page, "page_size": page_size}
+        return self._client._request("GET", f"/tasks/{task_id}/logs", params=params)
+
+
+class _ApisModule:
+    """API Market listing and discovery."""
+
+    def __init__(self, client: "TurboAPIClient"):
+        self._client = client
+
+    def list(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+        category: Optional[str] = None,
+        tags: Optional[List[str]] = None,
+        search: Optional[str] = None,
+        sort_by: str = "created_at",
+        sort_order: str = "desc",
+    ) -> APIListData:
+        """List available APIs in the marketplace.
+
+        Args:
+            page: Page number (1-indexed).
+            page_size: Items per page (max 100).
+            category: Filter by category slug.
+            tags: Filter by tag names.
+            search: Search in name and description.
+            sort_by: Sort field ('created_at', 'name', 'popularity').
+            sort_order: Sort order ('asc' or 'desc').
+
+        Returns:
+            A paginated list of APIResponse items.
+        """
+        params: Dict[str, Any] = {
+            "page": page,
+            "page_size": page_size,
+            "sort_by": sort_by,
+            "sort_order": sort_order,
+        }
+        if category:
+            params["category"] = category
+        if tags:
+            params["tags"] = ",".join(tags)
+        if search:
+            params["search"] = search
+
+        data = self._client._request("GET", "/apis", params=params)
+        return APIListData.from_dict(data)
+
+    def get(self, slug: str) -> APIResponse:
+        """Get details of a specific API by its slug.
+
+        Args:
+            slug: The API slug identifier (e.g. 'karaoke-maker').
+
+        Returns:
+            Full APIResponse with parameters and documentation.
+        """
+        data = self._client._request("GET", f"/apis/{slug}")
+        return APIResponse.from_dict(data)
+
+    def categories(
+        self,
+        *,
+        page: int = 1,
+        page_size: int = 20,
+    ) -> Dict[str, Any]:
+        """List API categories.
+
+        Args:
+            page: Page number (1-indexed).
+            page_size: Items per page.
+
+        Returns:
+            Raw response data containing category items.
+        """
+        params: Dict[str, Any] = {"page": page, "page_size": page_size}
+        return self._client._request("GET", "/apis/categories", params=params)
+
+
+class TurboAPIClient:
+    """TurboAPI client for calling AI services.
+
+    The client is configured once and provides access to the Call and Tasks APIs
+    via the `.call` and `.tasks` attributes.
+
+    Authentication is handled via an API key, passed as a Bearer token.
+
+    Usage:
+        client = TurboAPIClient(api_key="tbp_xxxxx")
+
+        # Quick call with blocking wait
+        result = client.call.create_and_wait("karaoke-maker", {
+            "audio_file": "https://...",
+            "task_key": "demo-001",
+        })
+        print(result.output)
+
+        # Or manual two-step
+        task = client.call.create("some-api", {"key": "value"})
+        status = client.call.get(task.task_id)
+        client.call.cancel(task.task_id)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        *,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+    ):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+        self._headers: Dict[str, str] = {
+            "Content-Type": "application/json",
+            "Accept": "application/json",
+        }
+        if api_key:
+            self._headers["Authorization"] = f"Bearer {api_key}"
+
+        self.apis = _ApisModule(self)
+        self.call = _CallModule(self)
+        self.tasks = _TasksModule(self)
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: Optional[Dict[str, Any]] = None,
+        params: Optional[Dict[str, Any]] = None,
+        headers: Optional[Dict[str, str]] = None,
+    ) -> Any:
+        """Make an HTTP request to the TurboAPI backend.
+
+        Args:
+            method: HTTP method.
+            path: URL path (appended to base_url).
+            json: JSON body.
+            params: Query parameters.
+            headers: Additional request headers.
+
+        Returns:
+            The 'data' field from the API response on success.
+
+        Raises:
+            TurboAPIError subclasses on failure.
+        """
+        url = f"{self.base_url}{path}"
+        req_headers = {**self._headers, **(headers or {})}
+
+        try:
+            with httpx.Client(timeout=self.timeout) as http:
+                response = http.request(
+                    method,
+                    url,
+                    json=json,
+                    params=params,
+                    headers=req_headers,
+                )
+        except httpx.TimeoutException as e:
+            raise TimeoutError(
+                f"Request timed out after {self.timeout}s",
+                error_code="TIMEOUT_ERROR",
+            ) from e
+        except httpx.TransportError as e:
+            raise NetworkError(
+                f"Network error: {e}",
+                error_code="NETWORK_ERROR",
+            ) from e
+
+        body = response.json()
+
+        if not body.get("success", False):
+            raise TurboAPIError.from_response(response.status_code, body)
+
+        return body.get("data")

turboapi/errors.py

@@ -0,0 +1,118 @@
+"""
+Exception hierarchy for the TurboAPI SDK.
+
+Maps backend error codes to typed Python exceptions.
+"""
+
+from typing import Any, Dict, Optional
+
+
+class TurboAPIError(Exception):
+    """Base exception for all TurboAPI SDK errors."""
+
+    def __init__(
+        self,
+        message: str,
+        status_code: Optional[int] = None,
+        error_code: Optional[str] = None,
+        details: Optional[Dict[str, Any]] = None,
+        request_id: Optional[str] = None,
+    ):
+        self.status_code = status_code
+        self.error_code = error_code or "UNKNOWN"
+        self.details = details
+        self.request_id = request_id
+        super().__init__(message)
+
+    @property
+    def message(self) -> str:
+        return str(self.args[0]) if self.args else ""
+
+    @classmethod
+    def from_response(
+        cls,
+        status_code: int,
+        body: dict,
+    ) -> "TurboAPIError":
+        """Create an appropriate error from an API error response."""
+        error = body.get("error", {})
+        error_code = error.get("code", "UNKNOWN")
+        message = error.get("message", "Unknown error")
+        details = error.get("details")
+        meta = body.get("meta", {})
+        request_id = meta.get("request_id")
+
+        # Map error codes to typed exceptions
+        error_class = _ERROR_CODE_MAP.get(error_code, TurboAPIError)
+
+        return error_class(
+            message=message,
+            status_code=status_code,
+            error_code=error_code,
+            details=details,
+            request_id=request_id,
+        )
+
+
+class AuthenticationError(TurboAPIError):
+    """Invalid or missing API key / authentication."""
+
+
+class RateLimitError(TurboAPIError):
+    """Rate limit exceeded."""
+
+    @property
+    def retry_after(self) -> Optional[int]:
+        """Get the retry-after duration in seconds, if provided."""
+        if self.details and "retry_after" in self.details:
+            return int(self.details["retry_after"])
+        return None
+
+
+class NotFoundError(TurboAPIError):
+    """Resource not found."""
+
+
+class ValidationError(TurboAPIError):
+    """Request validation failed."""
+
+
+class TaskError(TurboAPIError):
+    """Task execution failed."""
+
+
+class ServerError(TurboAPIError):
+    """Backend server error (5xx)."""
+
+
+class NetworkError(TurboAPIError):
+    """Network/connection error."""
+
+
+class TimeoutError(TurboAPIError):
+    """Request or task timeout."""
+
+
+# Map backend error code prefixes to exception classes
+_ERROR_CODE_MAP: Dict[str, type[TurboAPIError]] = {
+    # Auth errors
+    "AUTH_": AuthenticationError,
+    "UNAUTHORIZED": AuthenticationError,
+    "AUTH_TOKEN_EXPIRED": AuthenticationError,
+    "AUTH_INVALID_TOKEN": AuthenticationError,
+    # General errors
+    "NOT_FOUND": NotFoundError,
+    "API_NOT_FOUND": NotFoundError,
+    "USER_NOT_FOUND": NotFoundError,
+    "RATE_LIMITED": RateLimitError,
+    "RATE_LIMIT": RateLimitError,
+    "VALIDATION_ERROR": ValidationError,
+    "VALIDATION_": ValidationError,
+    "BAD_REQUEST": ValidationError,
+    "FORBIDDEN": AuthenticationError,
+    "CALL_": TaskError,
+    "CALL_FAILED": ServerError,
+    "INTERNAL_ERROR": ServerError,
+    "INTERNAL_": ServerError,
+    "POINTS_INSUFFICIENT": TaskError,
+}

turboapi/models.py

@@ -0,0 +1,273 @@
+"""
+Data models for the TurboAPI SDK.
+
+These mirror the backend schemas but are SDK-specific,
+not tied to backend implementation details.
+"""
+
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from typing import Any, Dict, List, Optional
+
+
+class TaskStatus(str, Enum):
+    """Task status enum matching backend TaskStatus."""
+
+    PENDING = "pending"
+    QUEUED = "queued"
+    STARTING = "starting"
+    PROCESSING = "processing"
+    SUCCEEDED = "succeeded"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+    TIMEOUT = "timeout"
+
+    @property
+    def is_terminal(self) -> bool:
+        """Check if this is a terminal (non-transient) status."""
+        return self in {
+            TaskStatus.SUCCEEDED,
+            TaskStatus.FAILED,
+            TaskStatus.CANCELLED,
+            TaskStatus.TIMEOUT,
+        }
+
+    @property
+    def is_active(self) -> bool:
+        """Check if the task is still being processed."""
+        return self in {
+            TaskStatus.QUEUED,
+            TaskStatus.STARTING,
+            TaskStatus.PROCESSING,
+        }
+
+
+class TaskPriority(str, Enum):
+    """Task priority levels."""
+
+    LOW = "low"
+    NORMAL = "normal"
+    HIGH = "high"
+    CRITICAL = "critical"
+
+
+@dataclass
+class TaskLogItem:
+    """A single log entry for a task."""
+
+    timestamp: str
+    level: str
+    message: str
+    details: Optional[Dict[str, Any]] = None
+
+
+@dataclass
+class TaskResponse:
+    """Full task response with status and optional output."""
+
+    id: str
+    task_id: str
+    name: str
+    status: Optional[TaskStatus] = None
+    progress: int = 0
+    total_items: int = 0
+    completed_items: int = 0
+    failed_items: int = 0
+    message: Optional[str] = None
+    error_message: Optional[str] = None
+    output: Optional[Any] = None
+    api_slug: Optional[str] = None
+    priority: Optional[str] = None
+    prediction_id: Optional[str] = None
+    retry_count: int = 0
+    max_retries: int = 3
+    logs: Optional[List[TaskLogItem]] = None
+    created_at: Optional[datetime] = None
+    started_at: Optional[datetime] = None
+    completed_at: Optional[datetime] = None
+    expires_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TaskResponse":
+        """Create from API response dict (data field)."""
+        status_raw = data.get("status")
+        status = TaskStatus(status_raw) if status_raw else None
+
+        logs_raw = data.get("logs")
+        logs = None
+        if logs_raw:
+            logs = [
+                TaskLogItem(
+                    timestamp=log["timestamp"],
+                    level=log["level"],
+                    message=log["message"],
+                    details=log.get("details"),
+                )
+                for log in logs_raw
+            ]
+
+        for dt_field in ("created_at", "started_at", "completed_at", "expires_at"):
+            val = data.get(dt_field)
+            if val and isinstance(val, str):
+                try:
+                    data[dt_field] = datetime.fromisoformat(
+                        val.replace("Z", "+00:00")
+                    )
+                except (ValueError, TypeError):
+                    data[dt_field] = val
+
+        return cls(
+            id=data.get("id") or data.get("task_id", ""),
+            task_id=data.get("task_id") or data.get("id", ""),
+            name=data.get("name", ""),
+            status=status,
+            progress=data.get("progress", 0),
+            total_items=data.get("total_items", 0),
+            completed_items=data.get("completed_items", 0),
+            failed_items=data.get("failed_items", 0),
+            message=data.get("message"),
+            error_message=data.get("error_message"),
+            output=data.get("output"),
+            api_slug=data.get("api_slug"),
+            priority=data.get("priority"),
+            prediction_id=data.get("prediction_id"),
+            retry_count=data.get("retry_count", 0),
+            max_retries=data.get("max_retries", 3),
+            logs=logs,
+            created_at=data.get("created_at"),
+            started_at=data.get("started_at"),
+            completed_at=data.get("completed_at"),
+            expires_at=data.get("expires_at"),
+        )
+
+
+@dataclass
+class TaskListResponse:
+    """Paginated task list."""
+
+    items: List[TaskResponse]
+    total: int
+    page: int
+    page_size: int
+    total_pages: int
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "TaskListResponse":
+        items_raw = data.get("items", [])
+        pagination = data.get("pagination", {})
+        items = [TaskResponse.from_dict(item) for item in items_raw]
+        return cls(
+            items=items,
+            total=pagination.get("total", 0),
+            page=pagination.get("page", 1),
+            page_size=pagination.get("page_size", 20),
+            total_pages=pagination.get("total_pages", 0),
+        )
+
+
+@dataclass
+class APIResponse:
+    id: str
+    name: str
+    slug: str
+    description: Optional[str] = None
+    category_id: Optional[int] = None
+    endpoint: Optional[str] = None
+    method: Optional[str] = None
+    documentation: Optional[Dict[str, Any]] = None
+    pricing: Optional[Dict[str, Any]] = None
+    status: str = "published"
+    is_official: bool = False
+    api_type: Optional[str] = None
+    handler_name: Optional[str] = None
+    upstream_platform_id: Optional[str] = None
+    parameters: Optional[Dict[str, Any]] = None
+    tags: List[str] = field(default_factory=list)
+    config_json: Optional[Dict[str, Any]] = None
+    show_detail: bool = True
+    created_at: Optional[datetime] = None
+    updated_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "APIResponse":
+        for dt_field in ("created_at", "updated_at"):
+            val = data.get(dt_field)
+            if val and isinstance(val, str):
+                try:
+                    data[dt_field] = datetime.fromisoformat(val.replace("Z", "+00:00"))
+                except (ValueError, TypeError):
+                    pass
+        return cls(
+            id=str(data.get("id", "")),
+            name=data.get("name", ""),
+            slug=data.get("slug", ""),
+            description=data.get("description"),
+            category_id=data.get("category_id"),
+            endpoint=data.get("endpoint"),
+            method=data.get("method"),
+            documentation=data.get("documentation"),
+            pricing=data.get("pricing"),
+            status=data.get("status", "published"),
+            is_official=data.get("is_official", False),
+            api_type=data.get("api_type"),
+            handler_name=data.get("handler_name"),
+            upstream_platform_id=data.get("upstream_platform_id"),
+            parameters=data.get("parameters"),
+            tags=data.get("tags", []),
+            config_json=data.get("config_json"),
+            show_detail=data.get("show_detail", True),
+            created_at=data.get("created_at"),
+            updated_at=data.get("updated_at"),
+        )
+
+
+@dataclass
+class CategoryResponse:
+    id: int
+    name: str
+    slug: str
+    description: Optional[str] = None
+    icon_url: Optional[str] = None
+    sort_order: int = 0
+    created_at: Optional[datetime] = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "CategoryResponse":
+        val = data.get("created_at")
+        if val and isinstance(val, str):
+            try:
+                data["created_at"] = datetime.fromisoformat(val.replace("Z", "+00:00"))
+            except (ValueError, TypeError):
+                pass
+        return cls(
+            id=int(data.get("id", 0)),
+            name=data.get("name", ""),
+            slug=data.get("slug", ""),
+            description=data.get("description"),
+            icon_url=data.get("icon_url"),
+            sort_order=data.get("sort_order", 0),
+            created_at=data.get("created_at"),
+        )
+
+
+@dataclass
+class APIListData:
+    items: List[APIResponse]
+    total: int
+    page: int
+    page_size: int
+    total_pages: int
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "APIListData":
+        items_raw = data.get("items", [])
+        pagination = data.get("pagination", {})
+        items = [APIResponse.from_dict(item) for item in items_raw]
+        return cls(
+            items=items,
+            total=pagination.get("total", 0),
+            page=pagination.get("page", 1),
+            page_size=pagination.get("page_size", 20),
+            total_pages=pagination.get("total_pages", 0),
+        )

turboapi_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: turboapi-sdk
+Version: 0.1.0
+Summary: TurboAPI SDK - Call AI services through the TurboAPI platform
+Project-URL: Homepage, https://turboapi.ai
+Project-URL: Repository, https://github.com/turboapi/turboapi
+Author: TurboAPI Team
+License: MIT
+Keywords: ai,api,sdk,turboapi
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: pydantic<3,>=2
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.24; extra == 'dev'
+Requires-Dist: pytest-httpx>=0.35; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# TurboAPI SDK (Python)
+
+Python client for calling AI services through [TurboAPI](https://turboapi.ai).
+
+## Installation
+
+```bash
+pip install turboapi-sdk
+```
+
+## Quick Start
+
+```python
+from turboapi import TurboAPIClient
+
+client = TurboAPIClient(api_key="tbp_your_api_key_here")
+
+# Create a task and wait for result
+result = client.call.create_and_wait(
+    slug_id="karaoke-maker",
+    input={
+        "audio_file": "https://example.com/song.mp3",
+        "task_key": "my-first-task",
+    },
+    timeout=300,
+)
+print(f"Task completed! Output: {result.output}")
+
+# Or manage tasks manually
+task = client.call.create("some-api", {"key": "value"})
+print(f"Task ID: {task.task_id}, Status: {task.status}")
+
+# Poll for updates
+updated = client.call.get(task.task_id)
+if updated.status.is_terminal:
+    print(f"Output: {updated.output}")
+
+# Cancel a queued task
+client.call.cancel(task.task_id)
+
+# List your recent tasks
+tasks = client.tasks.list(status="succeeded", page=1, page_size=10)
+for t in tasks.items:
+    print(f"{t.task_id}: {t.name} - {t.status}")
+```
+
+## API Reference
+
+### TurboAPIClient
+
+```python
+TurboAPIClient(
+    api_key: str | None = None,
+    *,
+    base_url: str = "https://api.turboapi.ai/api/v1",
+    timeout: float = 30.0,
+)
+```
+
+### Call Module (`client.call`)
+
+| Method | Description |
+|--------|-------------|
+| `create(slug_id, input, *, prefer_wait=False)` | Submit a task |
+| `get(task_id)` | Get task status & result |
+| `cancel(task_id)` | Cancel a queued task |
+| `create_and_wait(slug_id, input, *, timeout=300, poll_interval=2)` | Submit & block until complete |
+
+### Tasks Module (`client.tasks`)
+
+| Method | Description |
+|--------|-------------|
+| `list(*, status, api_slug, page, page_size)` | List your tasks |
+| `get(task_id)` | Get task detail |
+| `logs(task_id, *, page, page_size)` | Get execution logs |
+
+## Error Handling
+
+```python
+from turboapi import TurboAPIClient
+from turboapi.errors import (
+    AuthenticationError,
+    RateLimitError,
+    NotFoundError,
+    TimeoutError,
+)
+
+client = TurboAPIClient(api_key="...")
+
+try:
+    result = client.call.create_and_wait("some-api", {"key": "value"})
+except AuthenticationError:
+    print("Check your API key")
+except RateLimitError as e:
+    print(f"Slow down! Retry after {e.retry_after}s")
+except NotFoundError:
+    print("Task or API not found")
+except TimeoutError:
+    print("Task did not complete in time")
+```
+
+## Task Statuses
+
+| Status | Terminal | Description |
+|--------|----------|-------------|
+| `pending` | No | Waiting to be queued |
+| `queued` | No | In queue awaiting execution |
+| `starting` | No | Worker starting up |
+| `processing` | No | Execution in progress |
+| `succeeded` | Yes | Completed successfully |
+| `failed` | Yes | Execution failed |
+| `cancelled` | Yes | Cancelled by user |
+| `timeout` | Yes | Timed out |

turboapi_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+turboapi/__init__.py,sha256=KzrIX_f9NhZK9C91rbiF-LLIha8htIy-JU3fFrC53k0,1113
+turboapi/client.py,sha256=Pgjmrtr5WUca6ebWBvV-5JnNg7lv0TvCXSV9fOQvkJU,10921
+turboapi/errors.py,sha256=fXaUXFT0IyRVEvMuY87RoiGbzUFrAwysHpidhgBb7VE,3202
+turboapi/models.py,sha256=ENcavLaq8q3epsqWlXgPGSuyVf8iZYnfAwF7V-5g4x4,8489
+turboapi_sdk-0.1.0.dist-info/METADATA,sha256=2kKUCzgkLsQjkj5NK0Luo-EhLv4UQAe8r2BiYFnZ_h0,3835
+turboapi_sdk-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+turboapi_sdk-0.1.0.dist-info/RECORD,,

turboapi_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any