spicyapi 0.1.0__py3-none-any.whl

spicyapi/__init__.py

@@ -0,0 +1,42 @@
+"""Official SpicyAPI client for Python.
+
+The public surface is re-exported here, so ``from spicyapi import SpicyClient``
+is the only import most programs need.
+"""
+
+from ._client import (
+    ACTIVE_STATES,
+    API_BASE_URL,
+    TERMINAL_STATES,
+    SpicyApiError,
+    SpicyClient,
+    SpicyTimeoutError,
+    SpicyUploadError,
+    SpicyWebhookError,
+    compute_webhook_signature,
+    is_terminal,
+    output_assets,
+    output_text,
+    verify_webhook,
+)
+
+__all__ = [
+    "ACTIVE_STATES",
+    "API_BASE_URL",
+    "TERMINAL_STATES",
+    "SpicyApiError",
+    "SpicyClient",
+    "SpicyTimeoutError",
+    "compute_webhook_signature",
+    "SpicyUploadError",
+    "SpicyWebhookError",
+    "is_terminal",
+    "output_assets",
+    "output_text",
+    "verify_webhook",
+]
+
+# 版本号的唯一出处是 _client.py，这里只是把它再导出一次，pyproject 也从那里读。
+# 写两处必然漂移，而漂移的表现是 PyPI 上的版本与 __version__ 对不上——排查时
+# 最误导人的那种。
+from ._client import __version__ as __version__

spicyapi/_client.py

@@ -0,0 +1,1046 @@
+"""Official SpicyAPI client for Python 3.11+.
+
+SpicyAPI serves image and video generation models behind one API. Text models are
+not covered on purpose: they speak the OpenAI, Anthropic and Gemini wire formats,
+so the official libraries for those already work against this service.
+
+Depends on the standard library only. The ten-minute polling deadline is a local
+safety bound, not a service guarantee.
+
+It covers the whole media workflow: discover a model, upload a reference file,
+confirm the price, create the task, wait for a terminal state, read the result,
+refresh an expired output link, and destroy the stored content afterwards.
+Webhook signature verification is a module-level function so a web handler can
+use it without constructing a client.
+"""
+
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+import random
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from collections.abc import Callable, Iterator, Mapping
+from typing import Any
+
+API_BASE_URL = "https://api.spicyapi.ai/api/v1"
+REQUEST_TIMEOUT_SECONDS = 30.0
+# Sending bytes is not an API call. 90 MiB in 30 seconds would demand a
+# sustained 25 Mbit/s uplink, and the failure reads as a network fault when it
+# is really this client hanging up on itself.
+UPLOAD_TIMEOUT_SECONDS = 10.0 * 60.0
+WAIT_TIMEOUT_SECONDS = 10.0 * 60.0
+TERMINAL_STATES = frozenset({"succeeded", "failed", "canceled", "expired"})
+ACTIVE_STATES = frozenset({"queued", "running"})
+# 版本号的唯一出处。放在这里而不是 __init__.py，是因为 __init__ 要 import 本模块，
+# 反过来读它就成了循环导入；而测试把本文件当成一个无父包的独立模块加载，相对导入
+# 在那里必然失败。__init__.py 与 pyproject 都从这里读。
+__version__ = "0.1.0"
+
+# 响应体的本地上限。见 _read_capped 的说明：这个数不是契约规定的。
+MAX_RESPONSE_BYTES = 8 * 1024 * 1024
+_READ_CHUNK = 64 * 1024
+
+RETRYABLE_HTTP = frozenset({408, 429, 500, 502, 503, 504})
+RETRYABLE_CODES = frozenset({429, 500, 50301})
+# 50302 挂在 503 上，只看 HTTP 状态就会把它当成一次普通的上游不可用重发。契约说
+# 这把幂等键已经把失败记下来了，沿用它只会把那次失败原样重放回来——重试四轮、
+# 四轮都注定失败，而最后那句错误看着像「重试过了还是不行」，把真正的处置点
+#（换一把新的幂等键再发）盖掉了。这个集合先于状态码判定生效。
+NON_RETRYABLE_CODES = frozenset({50302})
+
+IMAGE_CONTENT_TYPES = frozenset({"image/jpeg", "image/png", "image/webp", "image/gif"})
+AUDIO_VIDEO_CONTENT_TYPES = frozenset({"video/mp4", "video/webm", "audio/mpeg", "audio/wav"})
+UPLOAD_CONTENT_TYPES = IMAGE_CONTENT_TYPES | AUDIO_VIDEO_CONTENT_TYPES
+MAX_IMAGE_UPLOAD_BYTES = 10 * 1024 * 1024
+MAX_AUDIO_VIDEO_UPLOAD_BYTES = 90 * 1024 * 1024
+CONTENT_TYPE_BY_SUFFIX = {
+    ".gif": "image/gif",
+    ".jpeg": "image/jpeg",
+    ".jpg": "image/jpeg",
+    ".mp3": "audio/mpeg",
+    ".mp4": "video/mp4",
+    ".png": "image/png",
+    ".wav": "audio/wav",
+    ".webm": "video/webm",
+    ".webp": "image/webp",
+}
+
+WEBHOOK_TOLERANCE_SECONDS = 300
+WEBHOOK_MAX_BODY_BYTES = 1024 * 1024
+
+# What to do about a business code, straight from the published contract. These
+# are the cases where blind retrying is either useless or wrong.
+RECOVERY_BY_CODE: Mapping[int, str] = {
+    40003: (
+        "the stored bytes do not match the upload ticket (size, media type or signature): "
+        "request a new ticket with the exact contentType and byte count, PUT the file again, "
+        "then commit. Retrying the commit alone cannot change the stored object"
+    ),
+    40004: (
+        "the request is valid but no deployment serves this parameter combination: change the "
+        "parameter named in the message, or pick another model. The identical request fails again"
+    ),
+    40901: (
+        "the quote expired or the price changed before the funds were reserved: quote again and "
+        "resend with the new quoteId and expectedCost. Keep the original Idempotency-Key so an "
+        "already accepted task is recovered instead of created twice"
+    ),
+    50301: (
+        "the model has no usable deployment or effective price right now: retry later with "
+        "backoff, or choose another model"
+    ),
+    50302: (
+        "a synchronous generation failed upstream and the charge was refunded: the request can be "
+        "sent again, with a new Idempotency-Key so it is treated as a fresh submission"
+    ),
+    503: (
+        "a dependency is temporarily unavailable: wait for retry_after_seconds when the server "
+        "sent one, then retry"
+    ),
+}
+
+TransportResult = tuple[int, Mapping[str, str], bytes]
+Transport = Callable[[str, str, Mapping[str, str], bytes | None, float], TransportResult]
+
+
+class SpicyApiError(RuntimeError):
+    """HTTP, envelope, or network failure with support correlation fields."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int = 0,
+        code: int | None = None,
+        request_id: str = "",
+        retry_after_seconds: float | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+        self.retry_after_seconds = retry_after_seconds
+
+    @property
+    def recovery(self) -> str:
+        """Contract-defined recovery step, or an empty string when there is none.
+
+        Branch on ``code``, never on the message: the message is prose and is
+        translated according to the account's API error language.
+        """
+        return RECOVERY_BY_CODE.get(self.code, "") if self.code is not None else ""
+
+
+class SpicyUploadError(SpicyApiError):
+    """The presigned PUT to object storage failed.
+
+    Storage answers with its own status and an XML body rather than the
+    SpicyAPI envelope, so there is no business ``code`` to branch on. A 403
+    here usually means a ticket header was altered or dropped: both
+    ``Content-Type`` and ``Content-Length`` are part of the signature.
+    """
+
+
+class SpicyTimeoutError(TimeoutError):
+    """A local request or polling deadline elapsed; remote state is unknown."""
+
+    def __init__(self, message: str, *, task_id: str | None = None) -> None:
+        super().__init__(message)
+        self.task_id = task_id
+
+
+class SpicyWebhookError(ValueError):
+    """A webhook delivery failed verification and must not be acted on."""
+
+    def __init__(self, reason: str, message: str) -> None:
+        super().__init__(message)
+        self.reason = reason
+
+
+def _read_capped(stream: Any, limit: int = MAX_RESPONSE_BYTES) -> bytes:
+    """至多读 limit 字节，超了就报错，而不是一直读下去。
+
+    `read()` 读到的是对端想给多少就给多少。一个坏掉的中间层、或者一条被劫持的连接，
+    可以一直吐字节直到进程被 OOM 杀掉——而这中间没有任何一步会报错。
+
+    上限**不是契约规定的**，是我们自己取的工程值：2026-09-20 实测公开目录 121 个端点
+    共 273 KiB，带 inputSchema 的内部目录估算约 1.33 MiB，8 MiB 留着几倍的增长余量。
+    取 8 是为了和 Go 那份一致（TypeScript 那份目前是 4 MiB）。
+    """
+    chunks: list[bytes] = []
+    read = 0
+    while True:
+        chunk = stream.read(_READ_CHUNK)
+        if not chunk:
+            break
+        read += len(chunk)
+        if read > limit:
+            raise SpicyApiError(
+                f"response body exceeded the local {limit}-byte ceiling; "
+                "refusing to buffer an unbounded response"
+            )
+        chunks.append(chunk)
+    return b"".join(chunks)
+
+
+def _urllib_transport(
+    method: str,
+    url: str,
+    headers: Mapping[str, str],
+    body: bytes | None,
+    timeout: float,
+) -> TransportResult:
+    request = urllib.request.Request(url, data=body, headers=dict(headers), method=method)
+    try:
+        with urllib.request.urlopen(request, timeout=timeout) as response:
+            return response.status, dict(response.headers.items()), _read_capped(response)
+    except urllib.error.HTTPError as error:
+        return error.code, dict(error.headers.items()), _read_capped(error)
+
+
+def is_terminal(task: Mapping[str, Any]) -> bool:
+    """这条任务是否已经到终态，不会再变了。
+
+    带 wait_seconds 建任务时必须用它分支：拿到的**可能**是终态记录，也可能是
+    等待预算用尽后的受理响应。两者形状一样，只有 state 不同，所以「我传了
+    wait 所以它一定完成了」这个假设会静默地拿着一条还在跑的任务往下走。
+    """
+    return task.get("state") in TERMINAL_STATES
+
+
+def _header(headers: Mapping[str, str], name: str) -> str | None:
+    """大小写无关地取一个响应头。
+
+    HTTP 头名不分大小写，而 urllib 把服务端发来的大小写原样保留。按字面取的话，
+    服务端发 `retry-after` 就取不到——退避会悄悄改用本地的指数退避，不再听服务端
+    给的那个窗口。它不报错，只是不听话。
+    """
+    lowered = name.lower()
+    for key, value in headers.items():
+        if key.lower() == lowered:
+            return value
+    return None
+
+
+def _normalise_base_url(value: str, label: str = "base_url") -> str:
+    """校验并规范化 base URL。
+
+    不校验的代价是把 Bearer 密钥明文发出去：传一个 http:// 的地址，密钥就躺在
+    网络上，而调用方那边什么异常都看不到。TypeScript / Go / PHP / Java 四份都
+    校验，只有这里没有。回环地址上的 http 放行，本地联调要用。
+    """
+    parsed = urllib.parse.urlparse(value)
+    if not parsed.scheme or not parsed.netloc:
+        raise ValueError(f"{label} must be an absolute URL")
+    host = parsed.hostname or ""
+    loopback = host in {"localhost", "::1"} or host == "127.0.0.1" or host.startswith("127.")
+    if parsed.scheme != "https" and not (parsed.scheme == "http" and loopback):
+        raise ValueError(
+            f"{label} must use HTTPS; HTTP is allowed only for loopback development"
+        )
+    if parsed.username or parsed.password:
+        raise ValueError(f"{label} must not contain credentials")
+    if parsed.query or parsed.fragment:
+        raise ValueError(f"{label} must not contain a query or fragment")
+    return value.rstrip("/")
+
+
+def _user_agent() -> str:
+    """`spicyapi-python/<version>`，版本号只有一个来源。
+
+    不发这个头的话 urllib 会发它自己的默认值 `Python-urllib/3.x`。那不只是少了
+    版本遥测：本仓 scripts/check_contract.py 里就记着，文档站的边缘防护会把 urllib
+    的默认 UA 拒成 403。同一条规则哪天挂到 api 站上，所有 Python 用户一起 403，
+    而排查的人不会想到是 UA。
+    """
+    return f"spicyapi-python/{__version__}"
+
+
+def _parse_retry_after(value: str | None) -> float | None:
+    """Seconds from a Retry-After header, or None when it is absent or unusable."""
+    if value is None:
+        return None
+    try:
+        return max(0.0, float(value))
+    except ValueError:
+        return None
+
+
+def output_text(task: Mapping[str, Any]) -> str | None:
+    """The text answer of a finished task, or None when it produced files.
+
+    Some endpoints answer in ``output.text`` and carry no ``assets`` key at
+    all, so reading ``task["output"]["assets"]`` directly raises KeyError on a
+    perfectly successful task.
+    """
+    output = task.get("output")
+    if not isinstance(output, Mapping):
+        return None
+    text = output.get("text")
+    return text if isinstance(text, str) else None
+
+
+def output_assets(task: Mapping[str, Any]) -> list[dict[str, Any]]:
+    """Generated files of a finished task, or an empty list.
+
+    Returns [] both for a text answer and for a failed task, so callers never
+    have to distinguish "no assets key" from "empty assets list".
+    """
+    output = task.get("output")
+    if not isinstance(output, Mapping):
+        return []
+    assets = output.get("assets")
+    if not isinstance(assets, list):
+        return []
+    return [dict(asset) for asset in assets if isinstance(asset, Mapping)]
+
+
+def content_type_for_path(path: str) -> str:
+    """Upload content type inferred from a file name extension."""
+    suffix = os.path.splitext(path)[1].lower()
+    content_type = CONTENT_TYPE_BY_SUFFIX.get(suffix)
+    if content_type is None:
+        raise ValueError(
+            f"cannot infer an upload content type from {path!r}; "
+            f"pass content_type explicitly, one of {sorted(UPLOAD_CONTENT_TYPES)}"
+        )
+    return content_type
+
+
+def max_upload_bytes(content_type: str) -> int:
+    """Platform ceiling for this media type. A model's schema may allow less."""
+    return (
+        MAX_IMAGE_UPLOAD_BYTES
+        if content_type in IMAGE_CONTENT_TYPES
+        else MAX_AUDIO_VIDEO_UPLOAD_BYTES
+    )
+
+
+def compute_webhook_signature(
+    task_id: str,
+    timestamp: str | int,
+    raw_body: bytes,
+    secret: str,
+) -> str:
+    """Base64 HMAC-SHA256 over ``taskId.timestamp.hex(sha256(raw_body))``.
+
+    ``raw_body`` must be the exact bytes received. Re-serializing the parsed
+    JSON changes key order and whitespace, and the signature no longer matches.
+    """
+    digest = hashlib.sha256(raw_body).hexdigest()
+    message = f"{task_id}.{timestamp}.{digest}".encode()
+    mac = hmac.new(secret.encode(), message, hashlib.sha256)
+    return base64.b64encode(mac.digest()).decode()
+
+
+def verify_webhook(
+    *,
+    raw_body: bytes,
+    timestamp: str,
+    signature: str,
+    payload_version: int | str,
+    secret: str,
+    tolerance_seconds: int = WEBHOOK_TOLERANCE_SECONDS,
+    now: Callable[[], float] = time.time,
+    max_body_bytes: int = WEBHOOK_MAX_BODY_BYTES,
+) -> dict[str, Any]:
+    """Verify one ``callBackUrl`` delivery and return its parsed payload.
+
+    This verifies the signature scheme used by the per-task ``callBackUrl``:
+    ``base64(HMAC-SHA256(secret, "taskId.timestamp.hex(sha256(body))"))``, carried
+    in ``X-Webhook-Signature``. Naming it precisely matters because a second,
+    account-level delivery scheme is planned; when that ships it gets its own
+    verifier rather than extra arguments here, and code written today keeps working.
+
+    ``timestamp``, ``signature`` and ``payload_version`` are the
+    ``X-Webhook-Timestamp``, ``X-Webhook-Signature`` and
+    ``X-Webhook-Payload-Version`` headers. Raises SpicyWebhookError with a
+    machine-readable ``reason`` when the delivery must be rejected.
+
+    Deliveries are retried, so a receiver must be idempotent: for payload
+    version 2 the ``request_id`` field is the stable delivery identifier.
+    """
+    if len(raw_body) > max_body_bytes:
+        raise SpicyWebhookError("body_too_large", f"webhook body exceeds {max_body_bytes} bytes")
+    if not secret.strip():
+        raise SpicyWebhookError("invalid_secret", "webhook signing secret is required")
+    version = str(payload_version)
+    if version not in {"1", "2"}:
+        raise SpicyWebhookError("invalid_version", "webhook payload version must be 1 or 2")
+    if not timestamp.isdigit():
+        raise SpicyWebhookError("invalid_timestamp", "webhook timestamp must be Unix seconds")
+
+    try:
+        payload = json.loads(raw_body)
+    except (json.JSONDecodeError, UnicodeDecodeError) as error:
+        raise SpicyWebhookError("invalid_json", "webhook body is not valid JSON") from error
+    if not isinstance(payload, dict):
+        raise SpicyWebhookError("invalid_payload", "webhook body is not a JSON object")
+
+    # The task ID is part of the signed string, and the two payload versions
+    # keep it in different places.
+    if version == "1":
+        task_id = payload.get("task_id")
+    else:
+        data = payload.get("data")
+        task_id = data.get("taskId") if isinstance(data, dict) else None
+    if not isinstance(task_id, str) or not task_id:
+        raise SpicyWebhookError(
+            "invalid_payload",
+            f"webhook payload version {version} does not contain a task ID",
+        )
+
+    expected = compute_webhook_signature(task_id, timestamp, raw_body, secret)
+    # Constant time: a byte-by-byte comparison leaks how much of a forged
+    # signature was correct, which is enough to construct a valid one.
+    if not hmac.compare_digest(expected.encode(), signature.encode()):
+        raise SpicyWebhookError("invalid_signature", "webhook signature does not match")
+
+    # Freshness is checked only after the signature: an unauthenticated body
+    # should never decide anything, including whether it is too old.
+    seconds = int(timestamp)
+    if abs(int(now()) - seconds) > tolerance_seconds:
+        raise SpicyWebhookError(
+            "stale_timestamp",
+            f"webhook timestamp is more than {tolerance_seconds}s from now",
+        )
+
+    delivery_id = payload.get("request_id") if version == "2" else None
+    return {
+        "payload": payload,
+        "payload_version": int(version),
+        "task_id": task_id,
+        "delivery_id": delivery_id if isinstance(delivery_id, str) else None,
+        "timestamp": seconds,
+    }
+
+
+class SpicyClient:
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str = API_BASE_URL,
+        transport: Transport = _urllib_transport,
+        sleep: Callable[[float], None] = time.sleep,
+        monotonic: Callable[[], float] = time.monotonic,
+        random_value: Callable[[], float] = random.random,
+        request_timeout_seconds: float = REQUEST_TIMEOUT_SECONDS,
+        upload_timeout_seconds: float = UPLOAD_TIMEOUT_SECONDS,
+        wait_timeout_seconds: float = WAIT_TIMEOUT_SECONDS,
+        max_retries: int = 3,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("SPICY_API_KEY", "")
+        if not self.api_key:
+            raise ValueError("SPICY_API_KEY is required")
+        self.base_url = _normalise_base_url(base_url)
+        self.transport = transport
+        self.sleep = sleep
+        self.monotonic = monotonic
+        self.random_value = random_value
+        self.request_timeout_seconds = request_timeout_seconds
+        self.upload_timeout_seconds = upload_timeout_seconds
+        self.wait_timeout_seconds = wait_timeout_seconds
+        self.max_retries = max_retries
+
+    # ── Models ────────────────────────────────────────────────────────────
+
+    def list_models(
+        self,
+        *,
+        modality: str | None = None,
+        provider: str | None = None,
+        task: str | None = None,
+        search: str | None = None,
+        include_schema: bool | None = None,
+        include_examples: bool | None = None,
+    ) -> dict[str, Any]:
+        values: dict[str, str] = {}
+        for key, value in {
+            "modality": modality,
+            "provider": provider,
+            "task": task,
+            "search": search,
+            "includeSchema": None if include_schema is None else str(int(include_schema)),
+            "includeExamples": None if include_examples is None else str(int(include_examples)),
+        }.items():
+            if value is not None:
+                values[key] = value
+        suffix = f"?{urllib.parse.urlencode(values)}" if values else ""
+        return self._request("GET", f"/models{suffix}")
+
+    def get_model(self, model: str) -> dict[str, Any]:
+        if not model:
+            raise ValueError("model is required")
+        encoded = urllib.parse.quote(model, safe="")
+        return self._request("GET", f"/models/{encoded}")
+
+    # ── Tasks ─────────────────────────────────────────────────────────────
+
+    def quote_task(
+        self,
+        *,
+        model: str,
+        input_data: Mapping[str, Any],
+        callback_url: str | None = None,
+    ) -> dict[str, Any]:
+        """Price a task without creating it or reserving any funds.
+
+        Returns quoteId, estimatedCost, maxCharge and expiresAt. The quote is
+        bound to this account, API key and request and lives five minutes; pass
+        its quoteId together with estimatedCost as expectedCost to create_task
+        to be rejected rather than charged if the price moved in between.
+
+        A quote reserves nothing, so it never guarantees later availability.
+        """
+        body: dict[str, Any] = {"model": model, "input": dict(input_data)}
+        if callback_url is not None:
+            body["callBackUrl"] = callback_url
+        return self._request("POST", "/jobs/quote", body=body)
+
+    def create_task(
+        self,
+        *,
+        model: str,
+        input_data: Mapping[str, Any],
+        idempotency_key: str,
+        callback_url: str | None = None,
+        quote_id: str | None = None,
+        expected_cost: str | None = None,
+        wait_seconds: int | None = None,
+    ) -> dict[str, Any]:
+        """Submit one asynchronous generation task.
+
+        HTTP 202 means accepted, not finished. The estimated cost is held, not
+        charged; the final charge is capped at the hold.
+
+        Keep one Idempotency-Key per logical submission and reuse it for every
+        resend of that submission, including after a timeout or a dropped
+        connection. A lost response does not prove the task was not created,
+        and a fresh key turns an unknown outcome into a second paid task. The
+        same key with different request semantics returns 409 instead.
+
+        Pass quote_id and expected_cost from quote_task to make a price change
+        fail with business code 40901 before any funds are reserved.
+
+        There is deliberately no content-mode flag. What a model will produce is
+        decided by the model you pick, not by a per-request declaration, and the
+        request schema has no such field. Older clients may still send one; the
+        service accepts and ignores it.
+
+        wait_seconds holds the connection open for up to that many seconds so the
+        first poll is unnecessary. **It does not guarantee a finished task**: if
+        the budget runs out you get the ordinary accepted response and poll from
+        there, exactly as if you had not asked. Branch on the state, never on the
+        fact that you passed the parameter::
+
+            task = client.create_task(..., wait_seconds=30)
+            if not is_terminal(task):
+                task = client.wait_for_terminal(task["taskId"])
+
+        The server clamps anything above 60 and ignores anything that is not a
+        positive integer, so nothing is clamped here; only a negative value is
+        refused, since that is a caller mistake rather than a platform limit that
+        could be relaxed later. Disconnecting stops the wait and nothing else —
+        the task keeps running and is billed as usual.
+        """
+        if not idempotency_key.strip():
+            raise ValueError("Idempotency-Key is required")
+        body: dict[str, Any] = {"model": model, "input": dict(input_data)}
+        if callback_url is not None:
+            body["callBackUrl"] = callback_url
+        if quote_id is not None:
+            body["quoteId"] = quote_id
+        if expected_cost is not None:
+            body["expectedCost"] = expected_cost
+        path = "/jobs/createTask"
+        timeout_seconds = None
+        if wait_seconds is not None:
+            if wait_seconds < 0:
+                raise ValueError("wait_seconds must not be negative")
+            path = f"{path}?{urllib.parse.urlencode({'wait': wait_seconds})}"
+            # 本地请求超时必须容得下服务端那段等待，否则这一发会在服务端还在等的时候
+            # 就从本地断掉——功能看起来「不生效」，而真正的原因是两个超时撞在一起。
+            # 留 10 秒余量给建任务本身和网络往返。
+            timeout_seconds = max(self.request_timeout_seconds, wait_seconds + 10)
+        return self._request(
+            "POST",
+            path,
+            body=body,
+            headers={"Idempotency-Key": idempotency_key},
+            timeout_seconds=timeout_seconds,
+        )
+
+    def get_task(
+        self,
+        task_id: str,
+        *,
+        timeout_seconds: float | None = None,
+    ) -> dict[str, Any]:
+        if not task_id:
+            raise ValueError("task_id is required")
+        query = urllib.parse.urlencode({"taskId": task_id})
+        return self._request(
+            "GET",
+            f"/jobs/recordInfo?{query}",
+            timeout_seconds=timeout_seconds,
+        )
+
+    def list_tasks(
+        self,
+        *,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        state: str | None = None,
+        model: str | None = None,
+        limit: int | None = None,
+        cursor: str | None = None,
+    ) -> dict[str, Any]:
+        """List this API key's tasks, newest first; metadata only.
+
+        Dates are a UTC half-open interval [from, to) of at most 92 days.
+        Scope is this API key: other keys on the account and console
+        generations are not included.
+        """
+        # 只拒非正数——那是明确的调用方错误。**上限不在本地判**：平台哪天把它
+        # 从 100 放宽到 200，这里会替用户拒绝一个已经能用的值，而这种失效没有
+        # 任何信号——用户只看到 SDK 说不行，去查服务端却发现明明可以。同样的
+        # 理由适用于 X-Spicy-Retention 的上限，两处口径一致。
+        if limit is not None and limit < 1:
+            raise ValueError("limit must be a positive integer")
+        values: dict[str, str] = {}
+        for key, value in {
+            "from": from_date,
+            "to": to_date,
+            "state": state,
+            "model": model,
+            "limit": None if limit is None else str(limit),
+            "cursor": cursor,
+        }.items():
+            if value is None:
+                continue
+            if value == "":
+                # 空串不是「没设」：调用方算出了一个筛选条件，而结果是空的。
+                #
+                # 静默丢掉它，他会拿到**没筛过**的整张列表，而没有任何东西告诉他
+                # 筛选没生效；原样发出去则撞一个服务端的 400，而那句话里不会说是
+                # 哪个参数。两条路都不好，所以在这里点名拒掉。
+                raise ValueError(
+                    f"{key} must not be an empty string; omit it to leave that filter off"
+                )
+            values[key] = value
+        suffix = f"?{urllib.parse.urlencode(values)}" if values else ""
+        return self._request("GET", f"/jobs{suffix}")
+
+    def iter_tasks(
+        self,
+        *,
+        from_date: str | None = None,
+        to_date: str | None = None,
+        state: str | None = None,
+        model: str | None = None,
+        limit: int | None = None,
+    ) -> Iterator[dict[str, Any]]:
+        """Walk every page of list_tasks, yielding one task at a time.
+
+        Every filter is repeated unchanged on each page, as the contract
+        requires; changing one mid-walk makes the cursor meaningless. Pages
+        read live state rather than a frozen snapshot, so a task may move
+        between states while you paginate.
+        """
+        cursor: str | None = None
+        while True:
+            page = self.list_tasks(
+                from_date=from_date,
+                to_date=to_date,
+                state=state,
+                model=model,
+                limit=limit,
+                cursor=cursor,
+            )
+            yield from page.get("items") or []
+            cursor = page.get("nextCursor")
+            if not page.get("hasMore") or not cursor:
+                return
+
+    def retry_task(self, task_id: str, idempotency_key: str) -> dict[str, Any]:
+        if not task_id:
+            raise ValueError("task_id is required")
+        if not idempotency_key.strip():
+            raise ValueError("Idempotency-Key is required")
+        return self._request(
+            "POST",
+            "/jobs/retry",
+            body={"taskId": task_id},
+            headers={"Idempotency-Key": idempotency_key},
+        )
+
+    def purge_task(self, task_id: str) -> dict[str, Any]:
+        """Destroy a finished task's stored content: media, result and prompt.
+
+        Billing evidence is never touched. The ledger, the charged amount, the
+        model, the state, the timestamps and the request_id all remain, and the
+        response repeats that as billingRetained.
+
+        Only a terminal task can be destroyed; queued or running returns 400.
+        No Idempotency-Key is sent: this endpoint does not read one, the taskId
+        is the idempotency key, and a repeat returns the original purgedAt. So
+        a timed-out call is safe to send again.
+        """
+        if not task_id:
+            raise ValueError("task_id is required")
+        return self._request("POST", "/jobs/purge", body={"taskId": task_id})
+
+    def wait_for_terminal(
+        self,
+        task_id: str,
+        *,
+        timeout_seconds: float | None = None,
+    ) -> dict[str, Any]:
+        total_timeout = self.wait_timeout_seconds if timeout_seconds is None else timeout_seconds
+        deadline = self.monotonic() + total_timeout
+        interval = 2.0
+
+        while self.monotonic() < deadline:
+            remaining = deadline - self.monotonic()
+            # 剩余预算不够发一次有意义的请求时，直接跳出去抛下面那个**带 task_id**
+            # 的超时。
+            #
+            # 不设这道门槛的话，最后一圈会用一个近乎零的超时发请求，那个请求几乎
+            # 必然超时——而它抛的是「请求超时」，不带 task_id。于是调用方在最该
+            # 知道任务编号的时刻失去了它：任务还在跑、还在计费，而他手上只有一句
+            # 「请求超时了」。丢的不是一次轮询，是找回那条任务的唯一线索。
+            #
+            # 门槛取 1 秒：小于它的一次往返本来也拿不到有用的结果。
+            if remaining < 1.0:
+                break
+            try:
+                task = self.get_task(
+                    task_id,
+                    timeout_seconds=min(self.request_timeout_seconds, remaining),
+                )
+            except SpicyTimeoutError:
+                # 单发轮询超时不等于这次等待失败——预算还剩着，就接着轮。
+                #
+                # 让它原样抛出去会同时犯两个错。一是丢掉 task_id：这个超时来自
+                # _request，而 _request 不知道自己正在为哪条任务轮询。二是把一次
+                # 网络抖动升级成整次等待的终结——默认 600 秒的预算会因为第一发卡
+                # 满 30 秒就放弃，而任务还在跑、还在计费。
+                #
+                # 预算真的耗尽时，循环顶上那道门槛会跳出去，抛下面那个带 task_id
+                # 的超时。TypeScript 那份实现不需要这段：它整段等待共用一个 abort
+                # signal，而那个 signal 的 reason 本身就带着 taskId。这里没有
+                # signal，只能显式接住。
+                pass
+            else:
+                state = task.get("state")
+                if state in TERMINAL_STATES and not self._has_pending_assets(task):
+                    return task
+                if state not in TERMINAL_STATES and state not in ACTIVE_STATES:
+                    raise SpicyApiError(f"unknown task state: {state!r}", status=200, code=200)
+
+            delay = min(self._jitter(interval), max(0.0, deadline - self.monotonic()))
+            if delay > 0:
+                self.sleep(delay)
+            interval = min(interval * 1.5, 15.0)
+
+        raise SpicyTimeoutError(
+            f"task {task_id} exceeded the local {total_timeout}s polling deadline; "
+            "its remote state is unknown",
+            task_id=task_id,
+        )
+
+    @staticmethod
+    def _has_pending_assets(task: Mapping[str, Any]) -> bool:
+        """True while a succeeded task still has assets without a URL.
+
+        A task can reach succeeded before every output object has landed. Those
+        assets carry pending: true and no url, so returning here would hand the
+        caller a result it cannot download.
+        """
+        if task.get("state") != "succeeded":
+            return False
+        return any(
+            asset.get("pending") and not asset.get("unavailable")
+            for asset in output_assets(task)
+        )
+
+    # ── Media ─────────────────────────────────────────────────────────────
+
+    def create_upload_url(self, *, content_type: str, byte_count: int) -> dict[str, Any]:
+        """Request a presigned upload ticket for an exact number of bytes.
+
+        The ticket is not retried on a transient failure: each one is a signed
+        write authorization against a tight per-account fuse, and a second
+        ticket does not make the first one usable.
+        """
+        if content_type not in UPLOAD_CONTENT_TYPES:
+            raise ValueError(
+                f"content_type must be one of {sorted(UPLOAD_CONTENT_TYPES)}, got {content_type!r}"
+            )
+        limit = max_upload_bytes(content_type)
+        if byte_count < 1 or byte_count > limit:
+            raise ValueError(
+                f"{content_type} uploads must be between 1 and {limit} bytes, got {byte_count}"
+            )
+        return self._request(
+            "POST",
+            "/common/upload-url",
+            body={"contentType": content_type, "bytes": byte_count},
+            retryable=False,
+        )
+
+    def commit_file(self, file_id: str) -> dict[str, Any]:
+        """Verify and freeze an uploaded object; returns the spicy:// URI.
+
+        Only data["uri"] may be used in task input — never the upload URL, the
+        temporary object key, or the bare file ID. Repeating a successful
+        commit is idempotent, so this call is safe to retry.
+        """
+        if not file_id:
+            raise ValueError("file_id is required")
+        encoded = urllib.parse.quote(file_id, safe="")
+        return self._request("POST", f"/files/{encoded}/commit")
+
+    def upload_bytes(self, data: bytes, *, content_type: str) -> dict[str, Any]:
+        """Ticket, PUT and commit in one call; returns the commit record.
+
+        Put the returned ``uri`` into the model input field whose x-ui.widget
+        is "upload" (or inside the list for "multi-upload").
+        """
+        ticket = self.create_upload_url(content_type=content_type, byte_count=len(data))
+        max_bytes = ticket.get("maxBytes")
+        if isinstance(max_bytes, int) and len(data) > max_bytes:
+            raise SpicyUploadError(
+                f"file of {len(data)} bytes exceeds the ticket limit of {max_bytes} bytes",
+                status=413,
+            )
+        self._put_bytes(
+            str(ticket["uploadUrl"]),
+            # Every ticket header goes out exactly as received. Content-Type and
+            # Content-Length are both signed, so altering or dropping one makes
+            # storage answer 403 with an error that does not come from us.
+            dict(ticket.get("headers") or {}),
+            data,
+            method=str(ticket.get("method") or "PUT"),
+        )
+        return self.commit_file(str(ticket["fileId"]))
+
+    def upload_file(self, path: str, *, content_type: str | None = None) -> dict[str, Any]:
+        """Upload a local file. The content type is inferred from its name.
+
+        The type and the size are settled before the file is read: rejecting an
+        unsupported or oversized file should not cost 90 MiB of memory first.
+        """
+        resolved = content_type or content_type_for_path(path)
+        limit = max_upload_bytes(resolved)
+        size = os.path.getsize(path)
+        if size < 1 or size > limit:
+            raise ValueError(
+                f"{resolved} uploads must be between 1 and {limit} bytes, got {size}"
+            )
+        with open(path, "rb") as handle:
+            data = handle.read()
+        return self.upload_bytes(data, content_type=resolved)
+
+    def create_download_url(self, task_id: str, key: str | None = None) -> dict[str, Any]:
+        """Mint a fresh short-lived link to one of a task's outputs.
+
+        Ready results already carry a usable output.assets[].url, so this is
+        only needed once that link has expired. Polling the task again works
+        just as well. Fetch the returned URL without any Authorization header:
+        it is itself the credential.
+        """
+        if not task_id:
+            raise ValueError("task_id is required")
+        body: dict[str, Any] = {"taskId": task_id}
+        if key is not None:
+            body["key"] = key
+        return self._request("POST", "/common/download-url", body=body, retryable=False)
+
+    # ── Account ───────────────────────────────────────────────────────────
+
+    def get_balance(self) -> dict[str, Any]:
+        """Net available, held and total balance in USD decimal strings."""
+        return self._request("GET", "/chat/credit")
+
+    def get_usage(
+        self,
+        *,
+        from_date: str | None = None,
+        to_date: str | None = None,
+    ) -> dict[str, Any]:
+        """Settled spend and call counts for this API key over [from, to).
+
+        For reconciliation, not for progress: this endpoint has its own
+        account-wide budget of 30 requests per minute shared by every key, and
+        that limiter fails closed, so polling it can lock every key on the
+        account out of its own reporting. Follow a task with get_task instead.
+
+        Late settlement can change a previous day's total, so a figure read
+        today is not final.
+        """
+        values: dict[str, str] = {}
+        if from_date is not None:
+            values["from"] = from_date
+        if to_date is not None:
+            values["to"] = to_date
+        suffix = f"?{urllib.parse.urlencode(values)}" if values else ""
+        return self._request("GET", f"/usage{suffix}")
+
+    # ── Transport ─────────────────────────────────────────────────────────
+
+    def _put_bytes(
+        self,
+        url: str,
+        headers: Mapping[str, str],
+        data: bytes,
+        *,
+        method: str = "PUT",
+    ) -> None:
+        """Send the bytes to object storage. Not a SpicyAPI call.
+
+        No Authorization header: the presigned URL carries its own credential
+        and some storage implementations reject a request that has both. No
+        envelope either — a storage response body is XML, not our JSON.
+
+        One attempt only, on the upload timeout rather than the API timeout.
+        """
+        try:
+            status, _, _ = self.transport(method, url, headers, data, self.upload_timeout_seconds)
+        except TimeoutError as error:
+            raise SpicyTimeoutError(
+                f"upload exceeded the local {self.upload_timeout_seconds}s timeout"
+            ) from error
+        except (urllib.error.URLError, OSError) as error:
+            raise SpicyUploadError(f"presigned upload failed: {error}") from error
+        if not 200 <= status < 300:
+            raise SpicyUploadError(
+                f"presigned upload failed with HTTP {status}; the ticket headers must be sent "
+                "unchanged and the body must be exactly the declared number of bytes",
+                status=status,
+            )
+
+    def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Mapping[str, Any] | None = None,
+        headers: Mapping[str, str] | None = None,
+        timeout_seconds: float | None = None,
+        retryable: bool = True,
+    ) -> Any:
+        request_headers = {
+            "Accept": "application/json",
+            "User-Agent": _user_agent(),
+            "Authorization": f"Bearer {self.api_key}",
+            **({"Content-Type": "application/json"} if body is not None else {}),
+            **dict(headers or {}),
+        }
+        encoded_body = None if body is None else json.dumps(body, separators=(",", ":")).encode()
+        timeout = self.request_timeout_seconds if timeout_seconds is None else timeout_seconds
+        # 单发超时：显式传了预算就以它为准，没传才用客户端的默认请求超时。
+        #
+        # 写死用 self.request_timeout_seconds 会让「带 wait 建任务」静默失效——
+        # 服务端还在等，本地 30 秒就把这一发断掉了，表现是这个功能看起来没生效，
+        # 而真正的原因是两个超时撞在一起。
+        per_attempt = self.request_timeout_seconds if timeout_seconds is None else timeout
+        request_deadline = self.monotonic() + timeout
+
+        for attempt in range(self.max_retries + 1):
+            remaining = request_deadline - self.monotonic()
+            if remaining <= 0:
+                raise SpicyTimeoutError(
+                    f"request exceeded the local {timeout}s timeout"
+                )
+            try:
+                status, response_headers, raw = self.transport(
+                    method,
+                    f"{self.base_url}{path}",
+                    request_headers,
+                    encoded_body,
+                    min(per_attempt, remaining),
+                )
+            except TimeoutError as error:
+                if retryable and attempt < self.max_retries:
+                    self.sleep(min(
+                        self._retry_delay(attempt),
+                        max(0.0, request_deadline - self.monotonic()),
+                    ))
+                    continue
+                raise SpicyTimeoutError(
+                    f"request exceeded the local {timeout}s timeout"
+                ) from error
+            except (urllib.error.URLError, OSError) as error:
+                if retryable and attempt < self.max_retries:
+                    self.sleep(min(
+                        self._retry_delay(attempt),
+                        max(0.0, request_deadline - self.monotonic()),
+                    ))
+                    continue
+                raise SpicyApiError(f"network request failed: {error}") from error
+
+            retry_after = _parse_retry_after(_header(response_headers, "Retry-After"))
+            try:
+                envelope = json.loads(raw)
+            except (json.JSONDecodeError, UnicodeDecodeError) as error:
+                if retryable and attempt < self.max_retries and status in RETRYABLE_HTTP:
+                    self.sleep(min(
+                        self._retry_delay(attempt, _header(response_headers, "Retry-After")),
+                        max(0.0, request_deadline - self.monotonic()),
+                    ))
+                    continue
+                raise SpicyApiError(
+                    "response was not valid JSON", status=status
+                ) from error
+
+            code = envelope.get("code") if isinstance(envelope, dict) else None
+            message = envelope.get("msg") if isinstance(envelope, dict) else None
+            request_id = envelope.get("request_id", "") if isinstance(envelope, dict) else ""
+            failed = not 200 <= status < 300 or code != 200
+            # 40004 and 40901 never enter this set: the identical request gets
+            # the identical answer, and only the caller can change a parameter
+            # or accept a new price.
+            resend_helps = code not in NON_RETRYABLE_CODES and (
+                status in RETRYABLE_HTTP or code in RETRYABLE_CODES
+            )
+            if failed and retryable and resend_helps and attempt < self.max_retries:
+                self.sleep(min(
+                    self._retry_delay(attempt, _header(response_headers, "Retry-After")),
+                    max(0.0, request_deadline - self.monotonic()),
+                ))
+                continue
+            if failed:
+                raise SpicyApiError(
+                    message if isinstance(message, str) else f"request failed with HTTP {status}",
+                    status=status,
+                    code=code if isinstance(code, int) else None,
+                    request_id=request_id if isinstance(request_id, str) else "",
+                    retry_after_seconds=retry_after,
+                )
+            if "data" not in envelope:
+                raise SpicyApiError(
+                    "successful envelope omitted data",
+                    status=status,
+                    code=code,
+                    request_id=request_id,
+                )
+            return envelope["data"]
+
+        raise AssertionError("retry loop exited unexpectedly")
+
+    def _jitter(self, seconds: float) -> float:
+        return seconds * (0.8 + self.random_value() * 0.4)
+
+    def _retry_delay(self, attempt: int, retry_after: str | None = None) -> float:
+        exponential = min(0.5 * (2**attempt), 8.0)
+        server_delay = _parse_retry_after(retry_after) or 0.0
+        return max(self._jitter(exponential), server_delay)

spicyapi-0.1.0.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.5
+Name: spicyapi
+Version: 0.1.0
+Summary: Official Python client for SpicyAPI — image, video and text generation behind one API.
+Project-URL: Homepage, https://spicyapi.ai
+Project-URL: Documentation, https://docs.spicyapi.ai
+Project-URL: Source, https://github.com/Spicy-API/spicy-python
+Project-URL: Issues, https://spicyapi.ai/contact
+Author: SpicyAPI
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,api-client,image-generation,spicyapi,video-generation
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# spicyapi
+
+**Official Python SDK for [SpicyAPI](https://spicyapi.ai)** — image, video and text models behind one API.
+
+[Get a key](https://spicyapi.ai) · [Models](https://spicyapi.ai/models) · [Docs](https://docs.spicyapi.ai) · [Status](https://status.spicyapi.ai)
+
+</div>
+
+---
+
+One endpoint in front of 83 model families across 121 callable endpoints, billed in USD per request
+rather than in credits. Media generation is asynchronous and quotable before you spend; text models
+speak the OpenAI, Anthropic and Gemini wire formats.
+
+```bash
+pip install spicyapi
+```
+
+Requires Python 3.11+. **No runtime dependencies**: this package goes into your dependency tree, and
+every constraint it adds is one more chance of a conflict.
+
+## Generate something
+
+```python
+import os, uuid
+from spicyapi import SpicyClient, output_assets
+
+client = SpicyClient()  # reads SPICY_API_KEY from the environment
+
+model = client.get_model("MODEL_ID_FROM_CATALOG")     # copy a real id from list_models()
+quote = client.quote_task(model=model["model"], input_data={"prompt": "a lantern in fog"})
+print(quote["estimatedCost"], quote["maxCharge"])      # decide before you spend
+
+task = client.create_task(
+    model=model["model"],
+    input_data={"prompt": "a lantern in fog"},
+    idempotency_key=str(uuid.uuid4()),
+    quote_id=quote["quoteId"],
+    expected_cost=quote["estimatedCost"],
+)
+final = client.wait_for_terminal(task["taskId"])
+for asset in output_assets(final):                     # module-level helper, not a method
+    print(asset["url"])
+```
+
+Build the `input` from that model's own `inputSchema` — every model has different fields, and
+`list_models(include_schema=True)` returns them.
+
+## Start from a local file
+
+Image-to-video, face swap and image editing all need your material on our side first. Upload returns
+a `spicy://` URI; that is what goes into `input`.
+
+```python
+uploaded = client.upload_file("/path/to/reference.png")
+task = client.create_task(
+    model="MODEL_ID_FROM_CATALOG",
+    input_data={"image": uploaded["uri"], "prompt": "slow dolly in"},
+    idempotency_key=str(uuid.uuid4()),
+)
+```
+
+## Webhooks
+
+`verify_webhook` is a module-level function, so a request handler can use it without building a
+client. It compares in constant time and checks the timestamp only after the signature is valid.
+
+```python
+from spicyapi import verify_webhook
+
+delivery = verify_webhook(
+    raw_body=request.body,                      # the exact bytes, before any parsing
+    signature=request.headers["X-Webhook-Signature"],
+    timestamp=request.headers["X-Webhook-Timestamp"],
+    payload_version=request.headers["X-Webhook-Payload-Version"],
+    secret=os.environ["SPICY_WEBHOOK_SECRET"],
+)
+```
+
+Verify the raw bytes. Re-serialising the parsed JSON changes them, and the signature will never match.
+
+## Two things that will save you money
+
+**Keep one idempotency key per submission.** Reuse it for every resend of that submission, including
+after a timeout or a dropped connection. A lost response does not prove the task was not created — a
+fresh key turns an unknown outcome into a second paid task.
+
+**A task that succeeds is charged, even if the result disappoints.** Quote first when the price
+matters; `quote_task` reserves nothing.
+
+## What this package does not do
+
+**Text models.** They speak the OpenAI, Anthropic and Google Gemini wire formats, so the official
+libraries for those already work — point them at `https://api.spicyapi.ai/v1` with the same key.
+Wrapping them here would add nothing.
+
+**Browser, mobile and desktop apps.** Never ship this key inside an application: a key compiled into
+a client is a public key. Call from your server, or put
+`@spicyapi/proxy` in front.
+
+## Errors
+
+Every failure raises `SpicyApiError` with `status`, `code`, `request_id` and `retry_after_seconds`.
+Branch on `code`, never on the message text — messages are translated, codes are not.
+
+`503` is shared by three different business codes, so reading the HTTP status alone is not enough:
+
+| code | meaning | what to do |
+| --- | --- | --- |
+| `40003` | uploaded bytes do not match their ticket | upload again |
+| `40004` | no deployment serves that parameter combination | change the parameter named in the message |
+| `40901` | the price moved before the task was created | quote again, keep the same idempotency key |
+| `503` | a dependency is briefly unavailable | back off by `Retry-After` |
+| `50301` | the model has no usable deployment or price right now | do not hammer; refresh the catalogue |
+| `50302` | a synchronous generation failed upstream and was refunded | retry with a **new** idempotency key |
+
+`err.recovery` carries the same guidance at runtime.
+
+## Links
+
+- [Documentation](https://docs.spicyapi.ai)
+- [API reference](https://docs.spicyapi.ai/docs/api-reference)
+- [Source](https://github.com/Spicy-API/spicy-python)
+
+---
+
+<div align="center">
+<sub>
+
+Also available in [TypeScript](https://github.com/Spicy-API/spicy-sdk) · **Python** · [Go](https://github.com/Spicy-API/spicy-go) · [PHP](https://github.com/Spicy-API/spicy-php) · [Java](https://github.com/Spicy-API/spicy-java)
+
+</sub>
+</div>

spicyapi-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+spicyapi/__init__.py,sha256=zSh9DEw365woqNfICPUyS0GsGn41WE6SVzoS3MHLHKc,1053
+spicyapi/_client.py,sha256=8Ln6cMtLx6EVRA7UhqDe9hn_dI3A9JS1fIAfjhYCKUc,45627
+spicyapi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spicyapi-0.1.0.dist-info/METADATA,sha256=8aAM6f46OysAaQNYqJM-UiYxZVx8-U7rSRUEP85ym-I,6156
+spicyapi-0.1.0.dist-info/WHEEL,sha256=THafob7ofN-NsuMN7Mg4qZyHaQI7KkD-QlcQatYhXPo,87
+spicyapi-0.1.0.dist-info/licenses/LICENSE,sha256=ivhd3AXs0xBDlrRWrfas7it38wcrfVJ0uVw7rQvEMO0,1065
+spicyapi-0.1.0.dist-info/RECORD,,

spicyapi-0.1.0.dist-info/WHEEL

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

spicyapi-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 SpicyAPI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.