runmux 0.1.0__py3-none-any.whl

runmux/__init__.py

@@ -0,0 +1,28 @@
+"""RunMux — official Python SDK.
+
+Generate video with Seedance 2.0 and manage the face asset library, with
+submit-and-wait helpers so you never hand-roll polling.
+"""
+
+from __future__ import annotations
+
+from .assets import Assets
+from .client import RunmuxClient
+from .errors import RunmuxError
+from .faces import Faces
+from .files import Files
+from .videos import Videos
+from .webhooks import Webhooks
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "RunmuxClient",
+    "RunmuxError",
+    "Videos",
+    "Assets",
+    "Faces",
+    "Files",
+    "Webhooks",
+    "__version__",
+]

runmux/assets.py

@@ -0,0 +1,83 @@
+"""The face / portrait asset library: register media and poll until active."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any, Dict, List, Optional
+from urllib.parse import quote
+
+from .errors import RunmuxError
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import RunmuxClient
+
+
+class Assets:
+    def __init__(self, client: "RunmuxClient") -> None:
+        self._client = client
+
+    def create(
+        self,
+        *,
+        url: Optional[str] = None,
+        data_url: Optional[str] = None,
+        name: Optional[str] = None,
+        asset_type: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """Register a face/portrait asset by public URL or inline ``data_url``.
+
+        Returns a ``processing`` record. ``asset_type`` is ``"Image"`` or
+        ``"Video"``.
+        """
+        body: Dict[str, Any] = {}
+        if url is not None:
+            body["url"] = url
+        if data_url is not None:
+            body["dataUrl"] = data_url
+        if name is not None:
+            body["name"] = name
+        if asset_type is not None:
+            body["assetType"] = asset_type
+        return self._client.request("POST", "/v1/assets", body=body)
+
+    def get(self, id: str) -> Dict[str, Any]:
+        return self._client.request("GET", f"/v1/assets/{quote(id, safe='')}")
+
+    def list(self) -> List[Dict[str, Any]]:
+        res = self._client.request("GET", "/v1/assets")
+        if isinstance(res, dict):
+            return res.get("data") or []
+        return []
+
+    def delete(self, id: str) -> None:
+        self._client.request("DELETE", f"/v1/assets/{quote(id, safe='')}")
+
+    def wait_active(
+        self,
+        id: str,
+        interval: float = 3,
+        timeout: float = 120,
+    ) -> Dict[str, Any]:
+        """Poll an asset until it leaves ``processing``.
+
+        Returns the active asset record. Raises ``RunmuxError`` (carrying
+        ``statusReason``) if the asset fails or is rejected, or on timeout
+        (seconds).
+        """
+        deadline = time.monotonic() + timeout
+        while True:
+            asset = self.get(id)
+            status = asset.get("status")
+            if status == "active":
+                return asset
+            if status in ("failed", "rejected"):
+                raise RunmuxError(
+                    asset.get("statusReason") or "Asset failed processing.",
+                    code="bad_request",
+                )
+            if time.monotonic() >= deadline:
+                raise RunmuxError(
+                    f"Timed out waiting for asset {id} to become active.",
+                    code="upstream_timeout",
+                )
+            time.sleep(interval)

runmux/client.py

@@ -0,0 +1,132 @@
+"""The RunMux client — construct once with your API key, then use the resource
+namespaces: ``client.videos``, ``client.files``, ``client.assets``,
+``client.faces``, ``client.webhooks``.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Dict, Mapping, Optional
+
+import httpx
+
+from .assets import Assets
+from .errors import RunmuxError
+from .faces import Faces
+from .files import Files
+from .videos import Videos
+from .webhooks import Webhooks
+
+DEFAULT_BASE_URL = "https://api.runmux.com"
+
+
+class RunmuxClient:
+    """Synchronous RunMux client.
+
+    Args:
+        api_key: Your RunMux API key (Bearer). Falls back to the
+            ``RUNMUX_API_KEY`` environment variable.
+        base_url: API base URL. Default ``https://api.runmux.com``.
+        timeout: Per-request timeout in seconds. Default ``60``.
+        transport: Optional ``httpx`` transport override (for tests / custom
+            transports).
+
+    Raises:
+        RunmuxError: with ``code="invalid_key"`` if no API key is provided.
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = 60,
+        *,
+        transport: Optional[httpx.BaseTransport] = None,
+    ) -> None:
+        key = api_key if api_key is not None else os.environ.get("RUNMUX_API_KEY")
+        if not key:
+            raise RunmuxError(
+                "A RunMux API key is required (pass api_key or set RUNMUX_API_KEY).",
+                code="invalid_key",
+            )
+        self._api_key = key
+        self.base_url = (base_url or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self._http = httpx.Client(
+            base_url=self.base_url,
+            timeout=timeout,
+            transport=transport,
+            headers={
+                "authorization": f"Bearer {self._api_key}",
+                "content-type": "application/json",
+            },
+        )
+
+        self.videos = Videos(self)
+        self.files = Files(self)
+        self.assets = Assets(self)
+        self.faces = Faces(self)
+        self.webhooks = Webhooks()
+
+    # -- context manager / lifecycle ------------------------------------
+
+    def close(self) -> None:
+        """Close the underlying HTTP connection pool."""
+        self._http.close()
+
+    def __enter__(self) -> "RunmuxClient":
+        return self
+
+    def __exit__(self, *exc: Any) -> None:
+        self.close()
+
+    # -- low-level request ----------------------------------------------
+
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        body: Any = None,
+        headers: Optional[Mapping[str, str]] = None,
+    ) -> Any:
+        """Low-level JSON request against the RunMux API.
+
+        Raises ``RunmuxError`` on any non-2xx response, parsing the API's
+        ``{"error": {code, message, request_id}}`` envelope when present.
+        """
+        try:
+            response = self._http.request(
+                method,
+                path,
+                json=body if body is not None else None,
+                headers=dict(headers) if headers else None,
+            )
+        except httpx.TimeoutException as exc:
+            raise RunmuxError(
+                "Request to RunMux timed out.", code="upstream_timeout"
+            ) from exc
+        except httpx.HTTPError as exc:
+            raise RunmuxError(
+                str(exc) or "Network request failed.", code="upstream_unavailable"
+            ) from exc
+
+        text = response.text
+        data: Any = None
+        if text:
+            try:
+                data = response.json()
+            except ValueError:
+                data = None
+
+        if not response.is_success:
+            err: Dict[str, Any] = {}
+            if isinstance(data, dict) and isinstance(data.get("error"), dict):
+                err = data["error"]
+            raise RunmuxError(
+                err.get("message") or f"RunMux request failed ({response.status_code}).",
+                status=response.status_code,
+                code=err.get("code") or "upstream_unavailable",
+                request_id=err.get("request_id"),
+            )
+        return data

runmux/errors.py

@@ -0,0 +1,54 @@
+"""Error type for the RunMux SDK."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+# Stable error codes returned by the RunMux API (mirrors the server's error codes).
+ERROR_CODES = (
+    "invalid_key",
+    "insufficient_balance",
+    "model_not_allowed",
+    "rate_limited",
+    "upstream_timeout",
+    "stream_interrupted",
+    "upstream_unavailable",
+    "internal_error",
+    "permission_denied",
+    "bad_request",
+)
+
+
+class RunmuxError(Exception):
+    """Raised for any non-2xx RunMux API response, or when a job/asset reaches a
+    failed terminal state.
+
+    Carries the API's ``code`` and ``request_id`` so callers can branch and
+    report precisely.
+
+    Attributes:
+        message: Human-readable description.
+        status: HTTP status code (0 when not from an HTTP response).
+        code: A stable machine-readable error code (see ``ERROR_CODES``).
+        request_id: Server-side request id for support, when available.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        status: int = 0,
+        code: str = "internal_error",
+        request_id: Optional[str] = None,
+    ) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status = status
+        self.code = code
+        self.request_id = request_id
+
+    def __repr__(self) -> str:  # pragma: no cover - cosmetic
+        return (
+            f"RunmuxError(message={self.message!r}, status={self.status!r}, "
+            f"code={self.code!r}, request_id={self.request_id!r})"
+        )

runmux/faces.py

@@ -0,0 +1,59 @@
+"""One-call face onboarding into the asset library."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Optional
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import RunmuxClient
+
+
+class Faces:
+    def __init__(self, client: "RunmuxClient") -> None:
+        self._client = client
+
+    def enroll(
+        self,
+        *,
+        url: Optional[str] = None,
+        data_url: Optional[str] = None,
+        name: Optional[str] = None,
+        interval: float = 3,
+        timeout: float = 120,
+    ) -> str:
+        """One-call face onboarding.
+
+        Registers the image in the asset library, waits until it is active, and
+        returns the ready-to-use ``asset://<id>`` reference.
+
+        Pass an ordinary (non-celebrity) face photo via ``url`` (a public https
+        image URL) or ``data_url`` (an inline ``data:`` URI / base64 image).
+
+        Raises ``RunmuxError`` (with the moderation reason) if the face is
+        rejected — e.g. a celebrity / copyrighted likeness.
+        """
+        created = self._client.assets.create(
+            url=url, data_url=data_url, name=name, asset_type="Image"
+        )
+        active = self._client.assets.wait_active(
+            created["id"], interval=interval, timeout=timeout
+        )
+        return active["assetUri"]
+
+    def enroll_asset(
+        self,
+        *,
+        url: Optional[str] = None,
+        data_url: Optional[str] = None,
+        name: Optional[str] = None,
+        interval: float = 3,
+        timeout: float = 120,
+    ) -> Dict[str, Any]:
+        """Same as :meth:`enroll` but returns the full asset record instead of
+        just the ``assetUri``."""
+        created = self._client.assets.create(
+            url=url, data_url=data_url, name=name, asset_type="Image"
+        )
+        return self._client.assets.wait_active(
+            created["id"], interval=interval, timeout=timeout
+        )

runmux/files.py

@@ -0,0 +1,64 @@
+"""Presigned direct-to-storage uploads."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Dict, Union
+
+import httpx
+
+from .errors import RunmuxError
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import RunmuxClient
+
+
+class Files:
+    def __init__(self, client: "RunmuxClient") -> None:
+        self._client = client
+
+    def create_upload(self, content_type: str) -> Dict[str, Any]:
+        """Ask RunMux for a presigned direct-to-storage upload URL for a given
+        content type.
+
+        Returns a dict with snake_case keys: ``id``, ``upload_url``,
+        ``file_url``, ``method``, ``headers``, ``expires_in``.
+        """
+        raw = self._client.request(
+            "POST", "/v1/files", body={"content_type": content_type}
+        )
+        return {
+            "id": raw.get("id"),
+            "upload_url": raw.get("upload_url"),
+            "file_url": raw.get("file_url"),
+            "method": raw.get("method"),
+            "headers": raw.get("headers") or {},
+            "expires_in": raw.get("expires_in"),
+        }
+
+    def upload(self, data: Union[bytes, bytearray], content_type: str) -> str:
+        """Upload bytes via a presigned URL and return the resulting ``file_url``.
+
+        The returned URL is usable as ``image_url`` / ``video_url`` / reference
+        media on :meth:`Videos.create`. Does the presign + PUT for you.
+        """
+        presign = self.create_upload(content_type)
+        method = presign.get("method") or "PUT"
+        try:
+            res = httpx.request(
+                method,
+                presign["upload_url"],
+                content=bytes(data),
+                headers={"content-type": content_type},
+                timeout=self._client.timeout,
+            )
+        except httpx.HTTPError as exc:
+            raise RunmuxError(
+                str(exc) or "Upload request failed.", code="upstream_unavailable"
+            ) from exc
+        if not res.is_success:
+            raise RunmuxError(
+                f"Upload PUT failed ({res.status_code}).",
+                status=res.status_code,
+                code="upstream_unavailable",
+            )
+        return presign["file_url"]

runmux/videos.py

@@ -0,0 +1,163 @@
+"""Video generation: submit, poll, and the one-call submit-and-wait helper."""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from urllib.parse import quote
+
+from .errors import RunmuxError
+
+if TYPE_CHECKING:  # pragma: no cover
+    from .client import RunmuxClient
+
+# Pythonic snake_case input key -> exact wire field name the RunMux API reads.
+# Most fields are snake_case on the wire too; a handful are camelCase (copied
+# verbatim from the JS SDK's toWireBody).
+_SNAKE_TO_WIRE = {
+    "model": "model",
+    "prompt": "prompt",
+    "image_url": "image_url",
+    "video_url": "video_url",
+    "reference_images": "reference_images",
+    "reference_videos": "reference_videos",
+    "reference_audios": "reference_audios",
+    # frame_images handled specially below
+    "resolution": "resolution",
+    "duration": "duration",
+    "ratio": "ratio",
+    "width": "width",
+    "height": "height",
+    "seed": "seed",
+    "audio": "audio",
+    "number_results": "number_results",
+    "auto_enroll_faces": "auto_enroll_faces",
+    # camelCase-on-the-wire fields:
+    "output_type": "outputType",
+    "output_format": "outputFormat",
+    "output_quality": "outputQuality",
+    "ttl": "ttl",
+    "upload_endpoint": "uploadEndpoint",
+    "safety": "safety",
+    "webhook_url": "webhook_url",
+}
+
+# Keys that are consumed by the SDK and never forwarded as body fields.
+_CONTROL_KEYS = {"idempotency_key"}
+
+
+def _normalize_frame_images(frame_images: Any) -> List[Any]:
+    """A frame image is a URL/asset:// string, or a dict with an explicit frame."""
+    out: List[Any] = []
+    for f in frame_images:
+        if isinstance(f, str):
+            out.append(f)
+        elif isinstance(f, dict):
+            entry: Dict[str, Any] = {"image": f.get("image")}
+            if "frame" in f and f["frame"] is not None:
+                entry["frame"] = f["frame"]
+            out.append(entry)
+        else:
+            out.append(f)
+    return out
+
+
+def to_wire_body(input: Dict[str, Any]) -> Dict[str, Any]:
+    """Map the SDK's snake_case input to the exact wire field names the API reads."""
+    body: Dict[str, Any] = {}
+    for key, value in input.items():
+        if key in _CONTROL_KEYS:
+            continue
+        if value is None:
+            continue
+        if key == "frame_images":
+            body["frame_images"] = _normalize_frame_images(value)
+            continue
+        wire_key = _SNAKE_TO_WIRE.get(key)
+        if wire_key is None:
+            # Unknown key: pass through unchanged so new server fields still work.
+            wire_key = key
+        body[wire_key] = value
+    return body
+
+
+def _is_batch(x: Dict[str, Any]) -> bool:
+    return x.get("batchId") is not None
+
+
+class Videos:
+    def __init__(self, client: "RunmuxClient") -> None:
+        self._client = client
+
+    def create(self, **input: Any) -> Dict[str, Any]:
+        """Submit a video job.
+
+        Returns the submitted job (``{"id", "status"}``) — or a batch
+        (``{"batchId", "results"}``) when ``number_results > 1``. Does NOT wait.
+        Use :meth:`run` to submit-and-wait, or :meth:`wait` afterwards.
+
+        Only ``model`` and ``prompt`` are required. Accepts Pythonic snake_case
+        keys (e.g. ``image_url``, ``reference_images``, ``auto_enroll_faces``,
+        ``number_results``); pass ``idempotency_key`` to dedup retries.
+        """
+        idempotency_key = input.get("idempotency_key")
+        headers = (
+            {"idempotency-key": idempotency_key} if idempotency_key else None
+        )
+        return self._client.request(
+            "POST", "/v1/videos", body=to_wire_body(input), headers=headers
+        )
+
+    def get(self, id: str) -> Dict[str, Any]:
+        """Fetch the current state of a job."""
+        return self._client.request("GET", f"/v1/videos/{quote(id, safe='')}")
+
+    def wait(
+        self,
+        id: str,
+        interval: float = 4,
+        timeout: float = 600,
+    ) -> Dict[str, Any]:
+        """Poll a job id until it reaches a terminal state.
+
+        Raises ``RunmuxError`` if the job fails or the timeout (seconds) elapses.
+        """
+        deadline = time.monotonic() + timeout
+        attempt = 0
+        while True:
+            job = self.get(id)
+            status = job.get("status")
+            if status == "succeeded":
+                return job
+            if status == "failed":
+                raise RunmuxError(
+                    job.get("errorMessage") or "Video generation failed.",
+                    code="upstream_unavailable",
+                )
+            if time.monotonic() >= deadline:
+                raise RunmuxError(
+                    f"Timed out waiting for video {id}.", code="upstream_timeout"
+                )
+            # Gentle backoff, capped at 2x the base interval.
+            time.sleep(min(interval * (1 + attempt * 0.25), interval * 2))
+            attempt += 1
+
+    def run(
+        self,
+        *,
+        interval: float = 4,
+        timeout: float = 600,
+        **input: Any,
+    ) -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """Submit AND wait for the result — the one-call path.
+
+        Returns the finished job (with ``url`` set) for a single result, or a
+        list of finished jobs for a batch (``number_results > 1``).
+        """
+        submitted = self.create(**input)
+        if _is_batch(submitted):
+            return [
+                self.wait(r["id"], interval=interval, timeout=timeout)
+                for r in submitted.get("results", [])
+            ]
+        return self.wait(submitted["id"], interval=interval, timeout=timeout)

runmux/webhooks.py

@@ -0,0 +1,32 @@
+"""Webhook signature verification."""
+
+from __future__ import annotations
+
+import hashlib
+import hmac
+from typing import Optional
+
+
+class Webhooks:
+    def verify(self, payload: str, signature: Optional[str], secret: str) -> bool:
+        """Verify a RunMux webhook signature.
+
+        RunMux sends ``X-Runmux-Signature: sha256=<hex>`` where the hex is
+        ``HMAC-SHA256(rawBody, secret)``. Pass the raw request body string
+        exactly as received (do not re-serialize a parsed object).
+
+        Returns ``True`` only on a constant-time match.
+
+        Args:
+            payload: The raw request body string.
+            signature: The value of the ``X-Runmux-Signature`` header
+                (e.g. ``"sha256=abc..."``), or ``None``.
+            secret: Your webhook secret.
+        """
+        if not signature or not secret:
+            return False
+        expected_hex = hmac.new(
+            secret.encode("utf-8"), payload.encode("utf-8"), hashlib.sha256
+        ).hexdigest()
+        expected = f"sha256={expected_hex}"
+        return hmac.compare_digest(expected, signature)

runmux-0.1.0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.4
+Name: runmux
+Version: 0.1.0
+Summary: Official RunMux Python SDK — video generation (Seedance 2.0) and the face asset library, with submit-and-wait helpers so you never hand-roll polling.
+Project-URL: Homepage, https://runmux.com
+Author: RunMux
+License: MIT
+Keywords: ai-video,runmux,sdk,seedance,video-generation
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: respx>=0.21; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# runmux
+
+Official Python SDK for **RunMux** — generate video with Seedance 2.0 and manage the
+face asset library, without hand-rolling polling loops or the multi-step face upload.
+
+Synchronous and Pythonic: construct one client, call resource methods with
+keyword arguments, get plain dicts back.
+
+## Install
+
+```bash
+pip install runmux
+```
+
+Requires Python 3.9+ (built on [httpx](https://www.python-httpx.org/)).
+
+## Quickstart — text to video (one call)
+
+```python
+import os
+from runmux import RunmuxClient
+
+client = RunmuxClient(api_key=os.environ["RUNMUX_API_KEY"])
+
+# run() submits the job AND waits for the result — no polling code on your side.
+video = client.videos.run(
+    model="seedance-2-0-mini",
+    prompt="a diamond necklace rotating on black velvet, soft highlights, product ad",
+    resolution="480p",
+    duration=5,
+)
+
+print(video["url"])  # downloadable result (expires ~1h unless you pass ttl)
+```
+
+The API key falls back to the `RUNMUX_API_KEY` environment variable, so
+`RunmuxClient()` works when that variable is set.
+
+Prefer to manage polling yourself? Use `create()` then `wait()`:
+
+```python
+job = client.videos.create(model="seedance-2-0-mini", prompt="...")
+done = client.videos.wait(job["id"])
+```
+
+## Putting a person in the video (faces)
+
+Raw human faces cannot be sent to the model directly. `faces.enroll()` runs the
+whole flow — register, wait until active, return the ready-to-use `asset://`
+reference:
+
+```python
+# Use an ordinary (non-celebrity) face photo.
+asset_uri = client.faces.enroll(url="https://your-cdn.com/model.jpg")
+
+video = client.videos.run(
+    model="seedance-2-0-mini",
+    prompt="Image 1 wearing the necklace, smiling at the camera",
+    image_url=asset_uri,  # or reference_images=[asset_uri]
+)
+```
+
+Even simpler — let RunMux enroll the face for you in one shot:
+
+```python
+video = client.videos.run(
+    model="seedance-2-0-mini",
+    prompt="Image 1 wearing the necklace",
+    image_url="https://your-cdn.com/model.jpg",
+    auto_enroll_faces=True,
+)
+```
+
+If a face is rejected (e.g. a celebrity / copyrighted likeness), the call raises
+a `RunmuxError` whose message explains why — switch to an ordinary face photo.
+
+## Image-to-video, batches, and inputs
+
+```python
+# Product image as the first frame:
+client.videos.run(
+    model="seedance-2-0-mini",
+    prompt="the ring rotates",
+    frame_images=["https://cdn/ring.jpg"],
+)
+
+# Several variations at once (number_results 1–4) returns a list:
+variations = client.videos.run(
+    model="seedance-2-0-mini", prompt="...", number_results=3
+)
+
+# Upload a local file, then reference it:
+with open("ring.png", "rb") as f:
+    file_url = client.files.upload(f.read(), "image/png")
+```
+
+`frame_images` entries may be plain URL/`asset://` strings, or dicts with an
+explicit frame, e.g. `{"image": "https://cdn/ring.jpg", "frame": "first"}`.
+
+## Webhooks
+
+Submit with `webhook_url` to get the result POSTed to you, then verify the
+signature against the raw request body:
+
+```python
+ok = client.webhooks.verify(
+    payload=raw_request_body,                 # the raw string body, not re-serialized
+    signature=request.headers.get("x-runmux-signature"),
+    secret=os.environ["RUNMUX_WEBHOOK_SECRET"],
+)
+```
+
+The signature scheme is `sha256=<hex>` where the hex is
+`HMAC-SHA256(raw_body, secret)`; comparison is constant-time.
+
+## Errors
+
+Every non-2xx response (and any failed job/asset) raises a `RunmuxError` with
+`.code`, `.status`, and `.request_id` for precise branching and support.
+
+```python
+from runmux import RunmuxError
+
+try:
+    client.videos.run(model="seedance-2-0-mini", prompt="...")
+except RunmuxError as exc:
+    print(exc.code, exc.status, exc.request_id)
+```
+
+## API surface
+
+- `client.videos` — `create`, `run`, `wait`, `get`
+- `client.assets` — `create`, `get`, `list`, `delete`, `wait_active`
+- `client.faces` — `enroll`, `enroll_asset`
+- `client.files` — `create_upload`, `upload`
+- `client.webhooks` — `verify`
+
+## Wire field names
+
+You pass clean Python snake_case keyword arguments; the SDK maps them to the
+exact field names the API expects. For example `image_url`, `reference_images`,
+`auto_enroll_faces`, and `number_results` are sent as-is, while `output_type`,
+`output_format`, `output_quality`, and `upload_endpoint` are sent as their
+camelCase wire equivalents. Pass `idempotency_key` to dedup retries — it is sent
+as the `Idempotency-Key` header, not a body field.

runmux-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+runmux/__init__.py,sha256=R_KSkPbSrRVfjL815BbR0FA8VLqIeL7U9uaaU4K6xKM,572
+runmux/assets.py,sha256=rZvcikeobiDLMAwc2pqiZVPOVEHNCXpZbINQUdnSzrY,2694
+runmux/client.py,sha256=T473umVyrh64MtebhkyrCWTREsxy6lmHsB2HpdbrOgw,4176
+runmux/errors.py,sha256=syEr0CRS6H3XPAHpAPvKLIgaxJecyAKhK_nYqr6N35U,1542
+runmux/faces.py,sha256=ZAfy3ShRxTlV7sZaZk2Ly09_gBDkNH7O-298qLh5__w,1920
+runmux/files.py,sha256=grtjmmbn5KCuwHGYkgUo5fH3QeFgoXgydlwHVnPd_Do,2195
+runmux/videos.py,sha256=SJ964_Wtpenn_-iR31XRCkcL4FPjOThbFCHNPtK64vc,5637
+runmux/webhooks.py,sha256=ub3vHWnnyyo9lp5wrs9yNqBclOeLjA2DGTCuZyriMao,1093
+runmux-0.1.0.dist-info/METADATA,sha256=J3XomkBlWxc0GqbJbNFlczLUpicxABX8NWuaqQtMPBc,5363
+runmux-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+runmux-0.1.0.dist-info/RECORD,,

runmux-0.1.0.dist-info/WHEEL

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