tezzinc 0.1.0__tar.gz

tezzinc-0.1.0/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: tezzinc
+Version: 0.1.0
+Summary: Official Python SDK for the Tezzinc video transcoding & subtitling platform.
+Author: Tezzinc
+License: MIT
+Project-URL: Homepage, https://tezzinc.com
+Project-URL: Documentation, https://tezzinc.com/#/docs/python
+Project-URL: Source, https://tezzinc.com
+Keywords: tezzinc,video,transcoding,ffmpeg,subtitles,api,sdk
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video :: Conversion
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-httpx>=0.30; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+
+# tezzinc — Python SDK
+
+The official Python client for the [Tezzinc](https://tezzinc.com) video
+transcoding & subtitling platform. A thin, typed wrapper over the same REST
+API the console and the MCP server use.
+
+```bash
+pip install tezzinc
+```
+
+## Quickstart
+
+```python
+import os
+from tezzinc import Tezzinc, TezzincError
+
+client = Tezzinc(api_key=os.environ["TEZZINC_API_KEY"])   # or just Tezzinc()
+
+# 1. Register a source
+asset = client.assets.create(
+    source_uri="https://example.com/clip.mp4",
+    content_type="video/mp4",
+)
+
+# 2. Submit a transcode
+job = client.jobs.create(
+    asset_id=asset.id,
+    spec={"preset_id": "h264_1080p"},
+    correlation_id="my-first-job",
+)
+print("submitted", job.id, "status=", job.status)
+
+# 3. Wait for it (polling; use a webhook on a server)
+final = client.jobs.wait_for(job.id, timeout=600, poll_interval=2.0)
+
+# 4. Read the outputs (signed, short-lived URLs)
+for out in final.outputs:
+    signed = client.outputs.signed_url(out.id, ttl_seconds=900)
+    print(out.preset_id, out.byte_size, signed.url)
+```
+
+## Configuration
+
+The client reads the API key from, in order: the `api_key=` argument, the
+`TEZZINC_API_KEY` environment variable, or `Tezzinc.from_config("config.json")`.
+The base URL defaults to `https://tezzinc.com` and can be overridden with
+`base_url=` or `TEZZINC_API_BASE`.
+
+## Errors
+
+Every non-2xx response raises `TezzincError` with `.status` (HTTP code),
+`.code` (machine-readable, e.g. `"quota_exceeded"`), `.message`, and
+`.headers` (read `Retry-After` on a 429). Transport failures raise
+`TezzincConnectionError` (a subclass, `status == 0`).
+
+```python
+from tezzinc import TezzincError
+
+try:
+    client.jobs.create(asset_id=asset.id, spec={"preset_id": "h264_1080p"})
+except TezzincError as e:
+    if e.status == 429:
+        retry_after = int(e.headers.get("Retry-After", "60"))
+    elif e.status >= 500:
+        ...  # retry with jitter
+```
+
+## Resources
+
+| Namespace | Methods |
+|-----------|---------|
+| `client.assets`  | `create`, `get`, `list`, `delete` |
+| `client.jobs`    | `create`, `get`, `list`, `cancel`, `wait_for` |
+| `client.presets` | `list` |
+| `client.outputs` | `signed_url` |
+
+Responses are attribute-accessible (`job.status`, `job.outputs[0].preset_id`)
+and also expose `.raw` for the underlying dict.
+
+MIT licensed.

tezzinc-0.1.0/README.md

@@ -0,0 +1,80 @@
+# tezzinc — Python SDK
+
+The official Python client for the [Tezzinc](https://tezzinc.com) video
+transcoding & subtitling platform. A thin, typed wrapper over the same REST
+API the console and the MCP server use.
+
+```bash
+pip install tezzinc
+```
+
+## Quickstart
+
+```python
+import os
+from tezzinc import Tezzinc, TezzincError
+
+client = Tezzinc(api_key=os.environ["TEZZINC_API_KEY"])   # or just Tezzinc()
+
+# 1. Register a source
+asset = client.assets.create(
+    source_uri="https://example.com/clip.mp4",
+    content_type="video/mp4",
+)
+
+# 2. Submit a transcode
+job = client.jobs.create(
+    asset_id=asset.id,
+    spec={"preset_id": "h264_1080p"},
+    correlation_id="my-first-job",
+)
+print("submitted", job.id, "status=", job.status)
+
+# 3. Wait for it (polling; use a webhook on a server)
+final = client.jobs.wait_for(job.id, timeout=600, poll_interval=2.0)
+
+# 4. Read the outputs (signed, short-lived URLs)
+for out in final.outputs:
+    signed = client.outputs.signed_url(out.id, ttl_seconds=900)
+    print(out.preset_id, out.byte_size, signed.url)
+```
+
+## Configuration
+
+The client reads the API key from, in order: the `api_key=` argument, the
+`TEZZINC_API_KEY` environment variable, or `Tezzinc.from_config("config.json")`.
+The base URL defaults to `https://tezzinc.com` and can be overridden with
+`base_url=` or `TEZZINC_API_BASE`.
+
+## Errors
+
+Every non-2xx response raises `TezzincError` with `.status` (HTTP code),
+`.code` (machine-readable, e.g. `"quota_exceeded"`), `.message`, and
+`.headers` (read `Retry-After` on a 429). Transport failures raise
+`TezzincConnectionError` (a subclass, `status == 0`).
+
+```python
+from tezzinc import TezzincError
+
+try:
+    client.jobs.create(asset_id=asset.id, spec={"preset_id": "h264_1080p"})
+except TezzincError as e:
+    if e.status == 429:
+        retry_after = int(e.headers.get("Retry-After", "60"))
+    elif e.status >= 500:
+        ...  # retry with jitter
+```
+
+## Resources
+
+| Namespace | Methods |
+|-----------|---------|
+| `client.assets`  | `create`, `get`, `list`, `delete` |
+| `client.jobs`    | `create`, `get`, `list`, `cancel`, `wait_for` |
+| `client.presets` | `list` |
+| `client.outputs` | `signed_url` |
+
+Responses are attribute-accessible (`job.status`, `job.outputs[0].preset_id`)
+and also expose `.raw` for the underlying dict.
+
+MIT licensed.

tezzinc-0.1.0/pyproject.toml

@@ -0,0 +1,40 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "tezzinc"
+version = "0.1.0"
+description = "Official Python SDK for the Tezzinc video transcoding & subtitling platform."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Tezzinc" }]
+keywords = ["tezzinc", "video", "transcoding", "ffmpeg", "subtitles", "api", "sdk"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Multimedia :: Video :: Conversion",
+    "Typing :: Typed",
+]
+dependencies = ["httpx>=0.24"]
+
+[project.optional-dependencies]
+dev = ["pytest>=7", "pytest-httpx>=0.30", "ruff>=0.1"]
+
+[project.urls]
+Homepage = "https://tezzinc.com"
+Documentation = "https://tezzinc.com/#/docs/python"
+Source = "https://tezzinc.com"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+tezzinc = ["py.typed"]

tezzinc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

tezzinc-0.1.0/src/tezzinc/__init__.py

@@ -0,0 +1,35 @@
+"""Tezzinc — the official Python SDK for the Tezzinc video platform.
+
+    from tezzinc import Tezzinc, TezzincError
+
+    client = Tezzinc(api_key="tz_live_...")   # or TEZZINC_API_KEY
+    asset = client.assets.create(source_uri="https://example.com/clip.mp4")
+    job = client.jobs.create(asset_id=asset.id, spec={"preset_id": "h264_1080p"})
+    final = client.jobs.wait_for(job.id, timeout=600)
+    for out in final.outputs:
+        print(client.outputs.signed_url(out.id).url)
+
+``import tezzinc`` and ``from tezzinc import Tezzinc`` both work — the import
+path is a stable alias for the company name.
+"""
+
+from __future__ import annotations
+
+__version__ = "0.1.0"
+
+from .client import Tezzinc
+from .errors import TezzincConnectionError, TezzincError
+from .models import Asset, Job, Output, Preset, Resource, SignedUrl
+
+__all__ = [
+    "Tezzinc",
+    "TezzincError",
+    "TezzincConnectionError",
+    "Asset",
+    "Job",
+    "Output",
+    "Preset",
+    "SignedUrl",
+    "Resource",
+    "__version__",
+]

tezzinc-0.1.0/src/tezzinc/client.py

@@ -0,0 +1,297 @@
+"""The Tezzinc client and its resource namespaces.
+
+    from tezzinc import Tezzinc
+    client = Tezzinc(api_key="tz_live_...")
+    asset = client.assets.create(source_uri="https://…/clip.mp4")
+    job = client.jobs.create(asset_id=asset.id, spec={"preset_id": "h264_1080p"})
+    final = client.jobs.wait_for(job.id, timeout=600)
+    for out in final.outputs:
+        print(client.outputs.signed_url(out.id).url)
+
+The client is a thin, dependency-light wrapper over the same REST surface the
+console and the MCP server call. It holds one :class:`httpx.Client` (connection
+pooling, HTTP/2) and translates every non-2xx response into a
+:class:`TezzincError`.
+"""
+
+from __future__ import annotations
+
+import json as _json
+import os
+import time
+from pathlib import Path
+from typing import Any, Mapping
+
+import httpx
+
+from .errors import TezzincConnectionError, TezzincError
+from .models import Asset, Job, Preset, SignedUrl
+
+__all__ = ["Tezzinc"]
+
+DEFAULT_BASE_URL = "https://tezzinc.com"
+DEFAULT_TIMEOUT = 30.0
+_TERMINAL = ("completed", "failed", "cancelled")
+
+
+class Tezzinc:
+    """Entry point to the Tezzinc API.
+
+    Parameters
+    ----------
+    api_key:
+        Your API key. Falls back to the ``TEZZINC_API_KEY`` environment
+        variable. Required — the SDK refuses to make unauthenticated calls
+        rather than sending them and getting a 401.
+    base_url:
+        API root. Falls back to ``TEZZINC_API_BASE`` / ``TEZZINC_BASE_URL``,
+        else ``https://tezzinc.com``.
+    timeout:
+        Per-request timeout in seconds.
+    """
+
+    def __init__(
+        self,
+        api_key: str | None = None,
+        *,
+        base_url: str | None = None,
+        timeout: float = DEFAULT_TIMEOUT,
+        _transport: httpx.BaseTransport | None = None,
+    ) -> None:
+        key = api_key or os.environ.get("TEZZINC_API_KEY")
+        if not key:
+            raise TezzincError(
+                0,
+                code="missing_api_key",
+                message=(
+                    "No API key. Pass api_key=... or set TEZZINC_API_KEY. "
+                    "Create a key in the console under Developer -> API keys."
+                ),
+            )
+        base = (
+            base_url
+            or os.environ.get("TEZZINC_API_BASE")
+            or os.environ.get("TEZZINC_BASE_URL")
+            or DEFAULT_BASE_URL
+        ).rstrip("/")
+        self._api_key = key
+        self.base_url = base
+        self._http = httpx.Client(
+            base_url=base,
+            timeout=timeout,
+            headers={
+                "Authorization": f"Bearer {key}",
+                "User-Agent": f"tezzinc-python/{_version()}",
+                "Accept": "application/json",
+            },
+            transport=_transport,
+        )
+        # Resource namespaces.
+        self.assets = _Assets(self)
+        self.jobs = _Jobs(self)
+        self.presets = _Presets(self)
+        self.outputs = _Outputs(self)
+
+    # -- alternate constructors -------------------------------------------
+    @classmethod
+    def from_config(cls, path: str | Path, **kwargs: Any) -> "Tezzinc":
+        """Build a client from a JSON config file: ``{"api_key": "...",
+        "base_url": "..."}``. Explicit kwargs win over the file."""
+        data = _json.loads(Path(path).read_text())
+        return cls(
+            api_key=kwargs.pop("api_key", None) or data.get("api_key"),
+            base_url=kwargs.pop("base_url", None) or data.get("base_url"),
+            **kwargs,
+        )
+
+    # -- context manager ---------------------------------------------------
+    def __enter__(self) -> "Tezzinc":
+        return self
+
+    def __exit__(self, *exc: object) -> None:
+        self.close()
+
+    def close(self) -> None:
+        self._http.close()
+
+    # -- the one request path everything funnels through ------------------
+    def _request(self, method: str, path: str, **kw: Any) -> Any:
+        try:
+            resp = self._http.request(method, path, **kw)
+        except httpx.TimeoutException as e:
+            raise TezzincConnectionError(f"request timed out: {e}") from e
+        except httpx.HTTPError as e:
+            raise TezzincConnectionError(f"network error: {e}") from e
+        if resp.status_code >= 400:
+            raise _error_from_response(resp)
+        if resp.status_code == 204 or not resp.content:
+            return None
+        try:
+            return resp.json()
+        except ValueError:
+            return resp.text
+
+
+class _Assets:
+    def __init__(self, client: Tezzinc) -> None:
+        self._c = client
+
+    def create(
+        self,
+        *,
+        source_uri: str,
+        content_type: str | None = None,
+        **extra: Any,
+    ) -> Asset:
+        """Register a source URL as an asset. The platform fetches and probes
+        it; the returned asset carries ``id`` and ``status``."""
+        body: dict[str, Any] = {"source_uri": source_uri}
+        if content_type:
+            body["content_type"] = content_type
+        body.update(extra)
+        return Asset(self._c._request("POST", "/v1/videos", json=body))
+
+    def get(self, asset_id: str) -> Asset:
+        return Asset(self._c._request("GET", f"/v1/videos/{asset_id}"))
+
+    def list(self, *, limit: int = 50, offset: int = 0, status: str | None = None) -> list[Asset]:
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if status:
+            params["status"] = status
+        rows = self._c._request("GET", "/v1/videos", params=params) or []
+        return [Asset(r) for r in rows]
+
+    def delete(self, asset_id: str) -> None:
+        self._c._request("DELETE", f"/v1/videos/{asset_id}")
+
+
+class _Jobs:
+    def __init__(self, client: Tezzinc) -> None:
+        self._c = client
+
+    def create(
+        self,
+        *,
+        asset_id: str,
+        spec: Mapping[str, Any] | None = None,
+        preset_id: str | None = None,
+        correlation_id: str | None = None,
+        idempotency_key: str | None = None,
+        **extra: Any,
+    ) -> Job:
+        """Submit a transcode against an asset.
+
+        ``spec`` mirrors the documented shape ``{"preset_id": "...",
+        "options": {...}}``; ``preset_id`` may also be passed directly. Extra
+        keyword args (priority, clip_start_seconds, …) pass through to the API.
+        """
+        spec = dict(spec or {})
+        pid = preset_id or spec.pop("preset_id", None)
+        if not pid:
+            raise TezzincError(
+                0, code="missing_preset",
+                message="jobs.create needs a preset_id (directly or in spec['preset_id']).",
+            )
+        body: dict[str, Any] = {"asset_id": asset_id, "preset_id": pid}
+        # Flatten spec['options'] and any remaining spec keys as passthrough.
+        options = spec.pop("options", None)
+        if isinstance(options, Mapping):
+            body.update(options)
+        body.update(spec)
+        body.update(extra)
+        if correlation_id:
+            body["correlation_id"] = correlation_id
+        headers = {"Idempotency-Key": idempotency_key} if idempotency_key else None
+        return Job(self._c._request("POST", "/v1/transcodes", json=body, headers=headers))
+
+    def get(self, job_id: str) -> Job:
+        return Job(self._c._request("GET", f"/v1/jobs/{job_id}"))
+
+    def list(self, *, limit: int = 50, offset: int = 0, status: str | None = None) -> list[Job]:
+        params: dict[str, Any] = {"limit": limit, "offset": offset}
+        if status:
+            params["status"] = status
+        rows = self._c._request("GET", "/v1/jobs", params=params) or []
+        return [Job(r) for r in rows]
+
+    def cancel(self, job_id: str) -> Job:
+        return Job(self._c._request("POST", f"/v1/jobs/{job_id}/cancel"))
+
+    def wait_for(
+        self,
+        job_id: str,
+        *,
+        timeout: float = 600.0,
+        poll_interval: float = 2.0,
+    ) -> Job:
+        """Poll until the job reaches a terminal state or ``timeout`` seconds
+        elapse. Raises :class:`TimeoutError` on timeout — the job itself is
+        untouched and can be polled again."""
+        deadline = time.monotonic() + timeout
+        while True:
+            job = self.get(job_id)
+            if job.get("status") in _TERMINAL:
+                return job
+            if time.monotonic() >= deadline:
+                raise TimeoutError(
+                    f"job {job_id} did not finish within {timeout:.0f}s "
+                    f"(last status: {job.get('status')})"
+                )
+            time.sleep(poll_interval)
+
+
+class _Presets:
+    def __init__(self, client: Tezzinc) -> None:
+        self._c = client
+
+    def list(self) -> list[Preset]:
+        rows = self._c._request("GET", "/v1/presets") or []
+        return [Preset(r) for r in rows]
+
+
+class _Outputs:
+    def __init__(self, client: Tezzinc) -> None:
+        self._c = client
+
+    def signed_url(self, output_id: str, *, ttl_seconds: int = 900) -> SignedUrl:
+        """Refresh a short-lived signed download URL for a finished output."""
+        return SignedUrl(
+            self._c._request(
+                "GET", f"/v1/outputs/{output_id}/signed-url", params={"ttl": ttl_seconds}
+            )
+        )
+
+
+# ---------------------------------------------------------------------------
+# helpers
+# ---------------------------------------------------------------------------
+
+
+def _error_from_response(resp: httpx.Response) -> TezzincError:
+    code = message = None
+    payload: Any = None
+    try:
+        payload = resp.json()
+        if isinstance(payload, dict):
+            detail = payload.get("detail", payload)
+            if isinstance(detail, dict):
+                code = detail.get("code")
+                message = detail.get("message") or detail.get("detail")
+            elif isinstance(detail, str):
+                message = detail
+    except ValueError:
+        message = resp.text or None
+    return TezzincError(
+        resp.status_code,
+        code=code,
+        message=message,
+        headers=resp.headers,
+        request_id=resp.headers.get("x-correlation-id") or resp.headers.get("x-request-id"),
+        payload=payload,
+    )
+
+
+def _version() -> str:
+    from . import __version__
+
+    return __version__

tezzinc-0.1.0/src/tezzinc/errors.py

@@ -0,0 +1,85 @@
+"""Exceptions raised by the Tezzinc SDK.
+
+Every non-2xx response from the API surfaces as a :class:`TezzincError`. The
+``status`` field is the HTTP status, ``code`` is the machine-readable error
+code (e.g. ``"quota_exceeded"``), ``message`` is the human explanation, and
+``headers`` exposes response headers (so callers can read ``Retry-After`` on a
+429). Network-level failures raise :class:`TezzincConnectionError`.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Iterator, Mapping
+
+
+class _CIHeaders(Mapping):
+    """A read-only, case-insensitive header map.
+
+    HTTP header names are case-insensitive, so ``e.headers.get("Retry-After")``
+    must work whether the transport stored it as ``Retry-After`` or
+    ``retry-after``. httpx lower-cases them; this restores lookup parity so the
+    documented recipe works regardless of the transport's casing.
+    """
+
+    def __init__(self, data: Mapping[str, str] | None = None) -> None:
+        self._d = {str(k).lower(): v for k, v in dict(data or {}).items()}
+
+    def __getitem__(self, key: str) -> str:
+        return self._d[str(key).lower()]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._d)
+
+    def __len__(self) -> int:
+        return len(self._d)
+
+    def __repr__(self) -> str:
+        return f"_CIHeaders({self._d!r})"
+
+
+class TezzincError(Exception):
+    """An error returned by the Tezzinc API.
+
+    Attributes
+    ----------
+    status:
+        The HTTP status code (0 for transport-level failures).
+    code:
+        The machine-readable error code, when the API supplied one.
+    message:
+        The human-readable message.
+    headers:
+        The response headers, so a caller can read ``Retry-After`` etc.
+    request_id:
+        The correlation id the server echoed, useful in support tickets.
+    """
+
+    def __init__(
+        self,
+        status: int,
+        code: str | None = None,
+        message: str | None = None,
+        *,
+        headers: Mapping[str, str] | None = None,
+        request_id: str | None = None,
+        payload: Any = None,
+    ) -> None:
+        self.status = status
+        self.code = code
+        self.message = message or code or f"HTTP {status}"
+        self.headers = _CIHeaders(headers)
+        self.request_id = request_id
+        self.payload = payload
+        super().__init__(f"[{status}] {self.code or 'error'}: {self.message}")
+
+
+class TezzincConnectionError(TezzincError):
+    """A transport-level failure (DNS, TLS, connection reset, timeout).
+
+    Carries ``status=0`` because no HTTP response was received. Kept a subclass
+    of :class:`TezzincError` so ``except TezzincError`` catches every failure a
+    caller can get from the SDK.
+    """
+
+    def __init__(self, message: str) -> None:
+        super().__init__(0, code="connection_error", message=message)

tezzinc-0.1.0/src/tezzinc/models.py

@@ -0,0 +1,93 @@
+"""Lightweight response models.
+
+The SDK returns objects with attribute access (``asset.id``, ``job.status``)
+rather than raw dicts, because the documentation and every example use dotted
+access. They are deliberately permissive: any field the API adds is still
+reachable as an attribute AND via ``[]`` / ``.raw``, so a server that grows a
+field does not require an SDK upgrade to read it. This mirrors how the REST
+surface evolves — additive, never renamed.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Iterator
+
+
+class Resource:
+    """A dict wrapper exposing keys as attributes.
+
+    ``resource.id`` and ``resource["id"]`` are equivalent; ``resource.raw`` is
+    the untouched dict. Nested dicts/lists are wrapped lazily so
+    ``job.outputs[0].preset_id`` works without the caller thinking about it.
+    """
+
+    __slots__ = ("_data",)
+
+    def __init__(self, data: dict[str, Any] | None = None) -> None:
+        object.__setattr__(self, "_data", dict(data or {}))
+
+    # -- attribute / item access ------------------------------------------
+    def __getattr__(self, name: str) -> Any:
+        try:
+            return _wrap(self._data[name])
+        except KeyError:
+            raise AttributeError(
+                f"{type(self).__name__!s} has no field {name!r} "
+                f"(available: {', '.join(sorted(self._data)) or 'none'})"
+            ) from None
+
+    def __getitem__(self, key: str) -> Any:
+        return _wrap(self._data[key])
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return _wrap(self._data.get(key, default))
+
+    @property
+    def raw(self) -> dict[str, Any]:
+        return self._data
+
+    def __contains__(self, key: object) -> bool:
+        return key in self._data
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._data)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Resource):
+            return self._data == other._data
+        return NotImplemented
+
+    def __repr__(self) -> str:
+        ident = self._data.get("id")
+        head = f"id={ident!r} " if ident else ""
+        return f"<{type(self).__name__} {head}{list(self._data)}>"
+
+
+def _wrap(value: Any) -> Any:
+    if isinstance(value, dict):
+        return Resource(value)
+    if isinstance(value, list):
+        return [_wrap(v) for v in value]
+    return value
+
+
+# Named subclasses so ``repr`` and ``isinstance`` read nicely; behaviour is
+# identical to Resource.
+class Asset(Resource):
+    pass
+
+
+class Job(Resource):
+    pass
+
+
+class Output(Resource):
+    pass
+
+
+class Preset(Resource):
+    pass
+
+
+class SignedUrl(Resource):
+    pass

tezzinc-0.1.0/src/tezzinc.egg-info/PKG-INFO

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: tezzinc
+Version: 0.1.0
+Summary: Official Python SDK for the Tezzinc video transcoding & subtitling platform.
+Author: Tezzinc
+License: MIT
+Project-URL: Homepage, https://tezzinc.com
+Project-URL: Documentation, https://tezzinc.com/#/docs/python
+Project-URL: Source, https://tezzinc.com
+Keywords: tezzinc,video,transcoding,ffmpeg,subtitles,api,sdk
+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.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video :: Conversion
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: httpx>=0.24
+Provides-Extra: dev
+Requires-Dist: pytest>=7; extra == "dev"
+Requires-Dist: pytest-httpx>=0.30; extra == "dev"
+Requires-Dist: ruff>=0.1; extra == "dev"
+
+# tezzinc — Python SDK
+
+The official Python client for the [Tezzinc](https://tezzinc.com) video
+transcoding & subtitling platform. A thin, typed wrapper over the same REST
+API the console and the MCP server use.
+
+```bash
+pip install tezzinc
+```
+
+## Quickstart
+
+```python
+import os
+from tezzinc import Tezzinc, TezzincError
+
+client = Tezzinc(api_key=os.environ["TEZZINC_API_KEY"])   # or just Tezzinc()
+
+# 1. Register a source
+asset = client.assets.create(
+    source_uri="https://example.com/clip.mp4",
+    content_type="video/mp4",
+)
+
+# 2. Submit a transcode
+job = client.jobs.create(
+    asset_id=asset.id,
+    spec={"preset_id": "h264_1080p"},
+    correlation_id="my-first-job",
+)
+print("submitted", job.id, "status=", job.status)
+
+# 3. Wait for it (polling; use a webhook on a server)
+final = client.jobs.wait_for(job.id, timeout=600, poll_interval=2.0)
+
+# 4. Read the outputs (signed, short-lived URLs)
+for out in final.outputs:
+    signed = client.outputs.signed_url(out.id, ttl_seconds=900)
+    print(out.preset_id, out.byte_size, signed.url)
+```
+
+## Configuration
+
+The client reads the API key from, in order: the `api_key=` argument, the
+`TEZZINC_API_KEY` environment variable, or `Tezzinc.from_config("config.json")`.
+The base URL defaults to `https://tezzinc.com` and can be overridden with
+`base_url=` or `TEZZINC_API_BASE`.
+
+## Errors
+
+Every non-2xx response raises `TezzincError` with `.status` (HTTP code),
+`.code` (machine-readable, e.g. `"quota_exceeded"`), `.message`, and
+`.headers` (read `Retry-After` on a 429). Transport failures raise
+`TezzincConnectionError` (a subclass, `status == 0`).
+
+```python
+from tezzinc import TezzincError
+
+try:
+    client.jobs.create(asset_id=asset.id, spec={"preset_id": "h264_1080p"})
+except TezzincError as e:
+    if e.status == 429:
+        retry_after = int(e.headers.get("Retry-After", "60"))
+    elif e.status >= 500:
+        ...  # retry with jitter
+```
+
+## Resources
+
+| Namespace | Methods |
+|-----------|---------|
+| `client.assets`  | `create`, `get`, `list`, `delete` |
+| `client.jobs`    | `create`, `get`, `list`, `cancel`, `wait_for` |
+| `client.presets` | `list` |
+| `client.outputs` | `signed_url` |
+
+Responses are attribute-accessible (`job.status`, `job.outputs[0].preset_id`)
+and also expose `.raw` for the underlying dict.
+
+MIT licensed.

tezzinc-0.1.0/src/tezzinc.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/tezzinc/__init__.py
+src/tezzinc/client.py
+src/tezzinc/errors.py
+src/tezzinc/models.py
+src/tezzinc/py.typed
+src/tezzinc.egg-info/PKG-INFO
+src/tezzinc.egg-info/SOURCES.txt
+src/tezzinc.egg-info/dependency_links.txt
+src/tezzinc.egg-info/requires.txt
+src/tezzinc.egg-info/top_level.txt
+tests/test_sdk.py

tezzinc-0.1.0/src/tezzinc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

tezzinc-0.1.0/src/tezzinc.egg-info/requires.txt

@@ -0,0 +1,6 @@
+httpx>=0.24
+
+[dev]
+pytest>=7
+pytest-httpx>=0.30
+ruff>=0.1

tezzinc-0.1.0/src/tezzinc.egg-info/top_level.txt

@@ -0,0 +1 @@
+tezzinc

tezzinc-0.1.0/tests/test_sdk.py

@@ -0,0 +1,198 @@
+"""SDK unit tests — no network. A mock httpx transport records requests and
+returns canned responses, so we assert the SDK builds the right calls and maps
+responses/errors correctly."""
+
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+
+from tezzinc import Job, Tezzinc, TezzincError
+from tezzinc.errors import TezzincConnectionError
+
+
+def make_client(handler, **kw):
+    return Tezzinc(api_key="tz_test_key", base_url="https://api.test", _transport=httpx.MockTransport(handler), **kw)
+
+
+# -- auth / construction -----------------------------------------------------
+
+
+def test_requires_api_key(monkeypatch):
+    monkeypatch.delenv("TEZZINC_API_KEY", raising=False)
+    with pytest.raises(TezzincError) as ei:
+        Tezzinc()
+    assert ei.value.code == "missing_api_key"
+
+
+def test_api_key_from_env(monkeypatch):
+    monkeypatch.setenv("TEZZINC_API_KEY", "tz_env")
+    c = Tezzinc(_transport=httpx.MockTransport(lambda r: httpx.Response(200, json=[])))
+    assert c._api_key == "tz_env"
+
+
+def test_sends_bearer_auth():
+    seen = {}
+
+    def handler(request):
+        seen["auth"] = request.headers.get("authorization")
+        seen["ua"] = request.headers.get("user-agent")
+        return httpx.Response(200, json=[])
+
+    make_client(handler).presets.list()
+    assert seen["auth"] == "Bearer tz_test_key"
+    assert seen["ua"].startswith("tezzinc-python/")
+
+
+# -- assets ------------------------------------------------------------------
+
+
+def test_assets_create_posts_source_uri():
+    seen = {}
+
+    def handler(request):
+        seen["path"] = request.url.path
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(201, json={"id": "a1", "status": "pending"})
+
+    asset = make_client(handler).assets.create(source_uri="https://x/y.mp4", content_type="video/mp4")
+    assert seen["path"] == "/v1/videos"
+    assert seen["body"] == {"source_uri": "https://x/y.mp4", "content_type": "video/mp4"}
+    assert asset.id == "a1"
+    assert asset.status == "pending"
+
+
+# -- jobs --------------------------------------------------------------------
+
+
+def test_jobs_create_flattens_spec():
+    seen = {}
+
+    def handler(request):
+        seen["path"] = request.url.path
+        seen["body"] = json.loads(request.content)
+        return httpx.Response(201, json={"id": "j1", "status": "queued", "outputs": []})
+
+    job = make_client(handler).jobs.create(
+        asset_id="a1",
+        spec={"preset_id": "h264_1080p", "options": {"priority": 5}},
+        correlation_id="c1",
+    )
+    assert seen["path"] == "/v1/transcodes"
+    assert seen["body"] == {
+        "asset_id": "a1",
+        "preset_id": "h264_1080p",
+        "priority": 5,
+        "correlation_id": "c1",
+    }
+    assert isinstance(job, Job) and job.id == "j1"
+
+
+def test_jobs_create_requires_preset():
+    c = make_client(lambda r: httpx.Response(201, json={}))
+    with pytest.raises(TezzincError) as ei:
+        c.jobs.create(asset_id="a1", spec={})
+    assert ei.value.code == "missing_preset"
+
+
+def test_jobs_create_idempotency_header():
+    seen = {}
+
+    def handler(request):
+        seen["idem"] = request.headers.get("idempotency-key")
+        return httpx.Response(201, json={"id": "j1"})
+
+    make_client(handler).jobs.create(asset_id="a1", preset_id="h264_720p", idempotency_key="k9")
+    assert seen["idem"] == "k9"
+
+
+def test_wait_for_polls_until_terminal():
+    states = iter(["queued", "processing", "completed"])
+
+    def handler(request):
+        return httpx.Response(200, json={"id": "j1", "status": next(states), "outputs": [{"id": "o1"}]})
+
+    job = make_client(handler).jobs.wait_for("j1", timeout=5, poll_interval=0)
+    assert job.status == "completed"
+    assert job.outputs[0].id == "o1"
+
+
+def test_wait_for_times_out():
+    def handler(request):
+        return httpx.Response(200, json={"id": "j1", "status": "processing"})
+
+    with pytest.raises(TimeoutError):
+        make_client(handler).jobs.wait_for("j1", timeout=0.05, poll_interval=0.01)
+
+
+# -- outputs -----------------------------------------------------------------
+
+
+def test_outputs_signed_url_passes_ttl():
+    seen = {}
+
+    def handler(request):
+        seen["path"] = request.url.path
+        seen["ttl"] = request.url.params.get("ttl")
+        return httpx.Response(200, json={"url": "https://signed/x"})
+
+    signed = make_client(handler).outputs.signed_url("o1", ttl_seconds=120)
+    assert seen["path"] == "/v1/outputs/o1/signed-url"
+    assert seen["ttl"] == "120"
+    assert signed.url == "https://signed/x"
+
+
+# -- error mapping -----------------------------------------------------------
+
+
+def test_error_maps_status_code_message_headers():
+    def handler(request):
+        return httpx.Response(
+            429,
+            json={"detail": {"code": "quota_exceeded", "message": "slow down"}},
+            headers={"Retry-After": "42"},
+        )
+
+    with pytest.raises(TezzincError) as ei:
+        make_client(handler).presets.list()
+    e = ei.value
+    assert e.status == 429
+    assert e.code == "quota_exceeded"
+    assert e.message == "slow down"
+    assert e.headers.get("Retry-After") == "42"
+
+
+def test_connection_error_is_tezzinc_error():
+    def handler(request):
+        raise httpx.ConnectError("boom")
+
+    with pytest.raises(TezzincConnectionError) as ei:
+        make_client(handler).presets.list()
+    assert ei.value.status == 0
+    assert isinstance(ei.value, TezzincError)
+
+
+# -- model access ------------------------------------------------------------
+
+
+def test_resource_attribute_and_item_access():
+    def handler(request):
+        return httpx.Response(200, json=[{"id": "p1", "codec": "h264", "extra": {"nested": 1}}])
+
+    presets = make_client(handler).presets.list()
+    assert presets[0].id == "p1"
+    assert presets[0]["codec"] == "h264"
+    assert presets[0].extra.nested == 1
+    assert presets[0].raw == {"id": "p1", "codec": "h264", "extra": {"nested": 1}}
+
+
+def test_missing_field_raises_helpful_attribute_error():
+    def handler(request):
+        return httpx.Response(200, json=[{"id": "p1"}])
+
+    p = make_client(handler).presets.list()[0]
+    with pytest.raises(AttributeError) as ei:
+        _ = p.nonexistent
+    assert "available" in str(ei.value)