veed 0.1.0__py3-none-any.whl

veed/__init__.py

@@ -0,0 +1,92 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+from ._errors import (
+    APIConnectionError,
+    APIError,
+    AuthenticationError,
+    InternalServerError,
+    InvalidRequestError,
+    JobCancelledError,
+    JobFailedError,
+    NotFoundError,
+    PermissionDeniedError,
+    RateLimitError,
+    VeedError,
+    WaitTimeoutError,
+)
+from ._types import (
+    JOB_STATUS_CANCELLED,
+    JOB_STATUS_COMPLETED,
+    JOB_STATUS_FAILED,
+    JOB_STATUS_PROCESSING,
+    File,
+    JobErrorDetail,
+    JobStatus,
+)
+from ._version import VERSION
+from .client import AsyncVeed, Veed
+from .resources.cleanAudio import (
+    AsyncCleanAudio,
+    CleanAudio,
+    CleanAudioJob,
+    CleanAudioJobError,
+    CleanAudioJobErrorCode,
+    CleanAudio,
+    CleanAudioOutputFormat,
+)
+from .resources.cleanAudioVideo import (
+    AsyncCleanAudioVideo,
+    CleanAudioVideo,
+    CleanAudioVideoJob,
+    CleanAudioVideo,
+)
+from .resources.dubbing import (
+    AsyncDubbing,
+    Dubbing,
+    DubbingJob,
+    DubbingJobError,
+    DubbingJobErrorCode,
+    Dubbing,
+)
+from .resources.dubbingPro import (
+    AsyncDubbingPro,
+    DubbingPro,
+)
+from .resources.fabric import (
+    AsyncFabric,
+    Fabric,
+    FabricJob,
+    FabricJobError,
+    FabricJobErrorCode,
+    FabricVideo,
+    FabricResolution,
+)
+from .resources.lipsync20 import (
+    AsyncLipsync20,
+    Lipsync20,
+    Lipsync20Job,
+    Lipsync20JobError,
+    Lipsync20JobErrorCode,
+    Lipsync20Video,
+)
+from .resources.videoBackgroundRemoval import (
+    AsyncVideoBackgroundRemoval,
+    VideoBackgroundRemoval,
+    VideoBackgroundRemovalJob,
+    VideoBackgroundRemovalJobError,
+    VideoBackgroundRemovalJobErrorCode,
+    VideoBackgroundRemovalFiles,
+    VideoBackgroundRemovalOutputCodec,
+)
+from .resources.videoBackgroundRemovalFast import (
+    AsyncVideoBackgroundRemovalFast,
+    VideoBackgroundRemovalFast,
+    VideoBackgroundRemovalFastOutputCodec,
+)
+from .resources.videoBackgroundRemovalGreenScreen import (
+    AsyncVideoBackgroundRemovalGreenScreen,
+    VideoBackgroundRemovalGreenScreen,
+    VideoBackgroundRemovalGreenScreenOutputCodec,
+)
+
+__version__ = VERSION

veed/_errors.py

@@ -0,0 +1,139 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing import Any, List, Optional
+
+# The server chooses Retry-After and no timeout covers a sleep, so an unclamped
+# header is a remote hang.
+MAX_RETRY_AFTER = 60.0
+
+
+class VeedError(Exception):
+    pass
+
+
+class APIConnectionError(VeedError):
+    pass
+
+
+class APIError(VeedError):
+    """HTTP-layer error: the request itself was rejected. For submits this
+    means no job was created (per the API contract)."""
+
+    def __init__(
+        self,
+        *,
+        status_code: int,
+        code: str,
+        message: str,
+        request_id: str,
+        details: Optional[List[Any]] = None,
+        retry_after: float = 0.0,
+    ) -> None:
+        self.status_code = status_code
+        self.code = code
+        self.message = message
+        self.request_id = request_id
+        self.details = details or []
+        self.retry_after = retry_after
+        super().__init__(f"veed: {status_code} {code}: {message} (request_id: {request_id})")
+
+
+class InvalidRequestError(APIError):
+    pass
+
+
+class AuthenticationError(APIError):
+    pass
+
+
+class PermissionDeniedError(APIError):
+    pass
+
+
+class NotFoundError(APIError):
+    pass
+
+
+class RateLimitError(APIError):
+    pass
+
+
+class InternalServerError(APIError):
+    pass
+
+
+_STATUS_MAP = {
+    400: InvalidRequestError,
+    401: AuthenticationError,
+    403: PermissionDeniedError,
+    404: NotFoundError,
+    422: InvalidRequestError,
+    429: RateLimitError,
+}
+
+
+def error_from_response(resp: Any) -> APIError:
+    status = resp.status_code
+    cls = _STATUS_MAP.get(status)
+    if cls is None:
+        cls = InternalServerError if status >= 500 else APIError
+    code = ""
+    message = ""
+    details = None
+    request_id = resp.headers.get("X-Request-ID", "")
+    try:
+        body = resp.json().get("error") or {}
+        code = body.get("code", "")
+        message = body.get("message", "")
+        details = body.get("details")
+        request_id = body.get("request_id") or request_id
+    except Exception:
+        message = resp.text[:200]
+    retry_after = 0.0
+    ra = resp.headers.get("Retry-After")
+    if ra and ra.isdigit():
+        retry_after = min(float(ra), MAX_RETRY_AFTER)
+    return cls(
+        status_code=status,
+        code=code,
+        message=message,
+        request_id=request_id,
+        details=details,
+        retry_after=retry_after,
+    )
+
+
+class JobFailedError(VeedError):
+    """Job-layer failure: the job was accepted, but rendering failed. Raised
+    by wait/generate, not as an HTTP error. `code` holds the model-specific
+    failure code and `job` the final job object."""
+
+    def __init__(self, *, job_id: str, code: str, message: str, details: Any = None, job: Any = None) -> None:
+        self.job_id = job_id
+        self.code = code
+        self.message = message
+        self.details = details or []
+        self.job = job
+        super().__init__(f"veed: job {job_id} failed ({code}): {message}")
+
+
+class JobCancelledError(VeedError):
+    def __init__(self, *, job_id: str, job: Any = None) -> None:
+        self.job_id = job_id
+        self.job = job
+        super().__init__(f"veed: job {job_id} was cancelled")
+
+
+class WaitTimeoutError(VeedError):
+    """wait/generate gave up before the job reached a terminal state. The job
+    may still finish server-side; resume with wait(job_id)."""
+
+    def __init__(self, *, job_id: str, timeout: float, job: Any = None) -> None:
+        self.job_id = job_id
+        self.timeout = timeout
+        self.job = job
+        super().__init__(
+            f"veed: timed out after {timeout}s waiting for job {job_id} (the job may still finish; resume with wait)"
+        )

veed/_transport.py

@@ -0,0 +1,258 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+from __future__ import annotations
+
+import asyncio
+import os
+import random
+import time
+from dataclasses import dataclass
+from typing import Any, Awaitable, Callable, Optional, TypeVar
+
+import httpx
+
+from ._errors import (
+    APIConnectionError,
+    APIError,
+    JobCancelledError,
+    JobFailedError,
+    RateLimitError,
+    VeedError,
+    WaitTimeoutError,
+    error_from_response,
+)
+from ._version import VERSION
+
+DEFAULT_BASE_URL = "https://api.veed.io"
+DEFAULT_WAIT_TIMEOUT = 900.0
+
+T = TypeVar("T")
+
+
+@dataclass
+class RequestOptions:
+    store_io: Optional[bool] = None
+    media_expiration_seconds: Optional[int] = None
+
+
+def _backoff(attempt: int) -> float:
+    return random.random() * min(0.5 * (2**attempt), 8.0)
+
+
+def _retryable(status: int) -> bool:
+    # POST retries are safe too: a rejected submit never creates a job.
+    return status in (408, 429) or status >= 500
+
+
+class BaseTransport:
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str],
+        base_url: Optional[str],
+        timeout: float,
+        max_retries: int,
+        store_io: Optional[bool] = None,
+        media_expiration_seconds: Optional[int] = None,
+    ) -> None:
+        self.api_key = api_key or os.environ.get("VEED_API_KEY") or ""
+        if not self.api_key:
+            raise VeedError(
+                "veed: missing API key: pass api_key=... or set VEED_API_KEY (create keys in your VEED workspace)"
+            )
+        self.base_url = (base_url or os.environ.get("VEED_BASE_URL") or DEFAULT_BASE_URL).rstrip("/")
+        self.timeout = timeout
+        self.max_retries = max_retries
+        self.store_io = store_io
+        self.media_expiration_seconds = media_expiration_seconds
+
+    def _headers(self, options: Optional[RequestOptions]) -> dict:
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Accept": "application/json",
+            "User-Agent": f"veed-sdk-python/{VERSION}",
+        }
+        store_io = self.store_io
+        media_expiration = self.media_expiration_seconds
+        if options is not None:
+            if options.store_io is not None:
+                store_io = options.store_io
+            if options.media_expiration_seconds is not None:
+                media_expiration = options.media_expiration_seconds
+        if store_io is not None:
+            headers["X-Veed-Store-IO"] = "1" if store_io else "0"
+        if media_expiration is not None:
+            headers["X-Veed-Media-Expiration-Seconds"] = str(media_expiration)
+        return headers
+
+    @staticmethod
+    def _unwrap(resp: httpx.Response) -> Any:
+        payload = resp.json()
+        if not isinstance(payload, dict) or "data" not in payload:
+            raise APIError(
+                status_code=resp.status_code,
+                code="",
+                message="response is missing the data envelope",
+                request_id=resp.headers.get("X-Request-ID", ""),
+            )
+        return payload["data"]
+
+
+class SyncTransport(BaseTransport):
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        store_io: Optional[bool] = None,
+        media_expiration_seconds: Optional[int] = None,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            store_io=store_io,
+            media_expiration_seconds=media_expiration_seconds,
+        )
+        self._client = http_client or httpx.Client(timeout=timeout)
+
+    def close(self) -> None:
+        self._client.close()
+
+    def request(self, method: str, path: str, *, json_body: Any = None, options: Optional[RequestOptions] = None) -> Any:
+        attempt = 0
+        while True:
+            try:
+                resp = self._client.request(
+                    method, self.base_url + path, json=json_body, headers=self._headers(options)
+                )
+            except httpx.HTTPError as exc:
+                if attempt < self.max_retries:
+                    time.sleep(_backoff(attempt))
+                    attempt += 1
+                    continue
+                raise APIConnectionError(f"veed: request failed: {exc}") from exc
+            if resp.status_code < 300:
+                return self._unwrap(resp)
+            err = error_from_response(resp)
+            if _retryable(resp.status_code) and attempt < self.max_retries:
+                time.sleep(err.retry_after if err.retry_after else _backoff(attempt))
+                attempt += 1
+                continue
+            raise err
+
+
+class AsyncTransport(BaseTransport):
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        store_io: Optional[bool] = None,
+        media_expiration_seconds: Optional[int] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        super().__init__(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            store_io=store_io,
+            media_expiration_seconds=media_expiration_seconds,
+        )
+        self._client = http_client or httpx.AsyncClient(timeout=timeout)
+
+    async def close(self) -> None:
+        await self._client.aclose()
+
+    async def request(
+        self, method: str, path: str, *, json_body: Any = None, options: Optional[RequestOptions] = None
+    ) -> Any:
+        attempt = 0
+        while True:
+            try:
+                resp = await self._client.request(
+                    method, self.base_url + path, json=json_body, headers=self._headers(options)
+                )
+            except httpx.HTTPError as exc:
+                if attempt < self.max_retries:
+                    await asyncio.sleep(_backoff(attempt))
+                    attempt += 1
+                    continue
+                raise APIConnectionError(f"veed: request failed: {exc}") from exc
+            if resp.status_code < 300:
+                return self._unwrap(resp)
+            err = error_from_response(resp)
+            if _retryable(resp.status_code) and attempt < self.max_retries:
+                await asyncio.sleep(err.retry_after if err.retry_after else _backoff(attempt))
+                attempt += 1
+                continue
+            raise err
+
+
+def _inspect(job: Any, job_id: str) -> Optional[VeedError]:
+    if job.status == "FAILED":
+        error = getattr(job, "error", None)
+        return JobFailedError(
+            job_id=job_id,
+            code=error.code if error else "",
+            message=error.message if error else "",
+            details=error.details if error else None,
+            job=job,
+        )
+    if job.status == "CANCELLED":
+        return JobCancelledError(job_id=job_id, job=job)
+    return None
+
+
+def wait_for_job(get_job: Callable[[], T], job_id: str, poll_interval: float, timeout: float) -> T:
+    deadline = time.monotonic() + timeout
+    last: Optional[T] = None
+    while True:
+        sleep_s = poll_interval
+        try:
+            job = get_job()
+            last = job
+            if job.status == "COMPLETED":  # type: ignore[attr-defined]
+                return job
+            terminal = _inspect(job, job_id)
+            if terminal is not None:
+                raise terminal
+        except RateLimitError as exc:
+            # The job keeps rendering server-side, so a rate-limited poll is
+            # not fatal to the wait.
+            sleep_s = exc.retry_after or poll_interval
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise WaitTimeoutError(job_id=job_id, timeout=timeout, job=last)
+        # Or a poll answered with Retry-After decides the wait's real length.
+        time.sleep(min(sleep_s, remaining))
+
+
+async def async_wait_for_job(
+    get_job: Callable[[], Awaitable[T]], job_id: str, poll_interval: float, timeout: float
+) -> T:
+    deadline = time.monotonic() + timeout
+    last: Optional[T] = None
+    while True:
+        sleep_s = poll_interval
+        try:
+            job = await get_job()
+            last = job
+            if job.status == "COMPLETED":  # type: ignore[attr-defined]
+                return job
+            terminal = _inspect(job, job_id)
+            if terminal is not None:
+                raise terminal
+        except RateLimitError as exc:
+            sleep_s = exc.retry_after or poll_interval
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise WaitTimeoutError(job_id=job_id, timeout=timeout, job=last)
+        await asyncio.sleep(min(sleep_s, remaining))

veed/_types.py

@@ -0,0 +1,37 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict
+
+# Kept as str (not an Enum/Literal) so a new server-side status never breaks
+# deserialization in old SDK versions.
+JobStatus = str
+
+JOB_STATUS_PROCESSING = "PROCESSING"
+JOB_STATUS_COMPLETED = "COMPLETED"
+JOB_STATUS_FAILED = "FAILED"
+JOB_STATUS_CANCELLED = "CANCELLED"
+
+
+class VeedModel(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
+class File(VeedModel):
+    """A downloadable media file produced by a job."""
+
+    url: str
+    content_type: Optional[str] = None
+    file_name: Optional[str] = None
+    file_size: Optional[int] = None
+
+
+class JobErrorDetail(VeedModel):
+    """One structured entry of a job-level failure."""
+
+    type: str
+    message: str
+    field: Optional[str] = None

veed/_version.py

@@ -0,0 +1,3 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+VERSION = "0.1.0"

veed/client.py

@@ -0,0 +1,119 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+from __future__ import annotations
+
+from typing import Optional
+
+import httpx
+
+from ._transport import AsyncTransport, SyncTransport
+from .resources import (
+    AsyncCleanAudio,
+    CleanAudio,
+    AsyncCleanAudioVideo,
+    CleanAudioVideo,
+    AsyncDubbing,
+    Dubbing,
+    AsyncDubbingPro,
+    DubbingPro,
+    AsyncFabric,
+    Fabric,
+    AsyncLipsync20,
+    Lipsync20,
+    AsyncVideoBackgroundRemoval,
+    VideoBackgroundRemoval,
+    AsyncVideoBackgroundRemovalFast,
+    VideoBackgroundRemovalFast,
+    AsyncVideoBackgroundRemovalGreenScreen,
+    VideoBackgroundRemovalGreenScreen,
+)
+
+
+class Veed:
+    """VEED API client. Construct once with your API key and reuse; safe to
+    share across threads.
+
+        client = veed.Veed()  # reads VEED_API_KEY
+    """
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        store_io: Optional[bool] = None,
+        media_expiration_seconds: Optional[int] = None,
+        http_client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._transport = SyncTransport(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            store_io=store_io,
+            media_expiration_seconds=media_expiration_seconds,
+            http_client=http_client,
+        )
+        self.cleanAudio = CleanAudio(self._transport)
+        self.cleanAudioVideo = CleanAudioVideo(self._transport)
+        self.dubbing = Dubbing(self._transport)
+        self.dubbingPro = DubbingPro(self._transport)
+        self.fabric = Fabric(self._transport)
+        self.lipsync20 = Lipsync20(self._transport)
+        self.videoBackgroundRemoval = VideoBackgroundRemoval(self._transport)
+        self.videoBackgroundRemovalFast = VideoBackgroundRemovalFast(self._transport)
+        self.videoBackgroundRemovalGreenScreen = VideoBackgroundRemovalGreenScreen(self._transport)
+
+    def close(self) -> None:
+        self._transport.close()
+
+    def __enter__(self) -> "Veed":
+        return self
+
+    def __exit__(self, *exc_info: object) -> None:
+        self.close()
+
+
+class AsyncVeed:
+    """Async VEED API client (asyncio + httpx.AsyncClient)."""
+
+    def __init__(
+        self,
+        *,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+        timeout: float = 60.0,
+        max_retries: int = 2,
+        store_io: Optional[bool] = None,
+        media_expiration_seconds: Optional[int] = None,
+        http_client: Optional[httpx.AsyncClient] = None,
+    ) -> None:
+        self._transport = AsyncTransport(
+            api_key=api_key,
+            base_url=base_url,
+            timeout=timeout,
+            max_retries=max_retries,
+            store_io=store_io,
+            media_expiration_seconds=media_expiration_seconds,
+            http_client=http_client,
+        )
+        self.cleanAudio = AsyncCleanAudio(self._transport)
+        self.cleanAudioVideo = AsyncCleanAudioVideo(self._transport)
+        self.dubbing = AsyncDubbing(self._transport)
+        self.dubbingPro = AsyncDubbingPro(self._transport)
+        self.fabric = AsyncFabric(self._transport)
+        self.lipsync20 = AsyncLipsync20(self._transport)
+        self.videoBackgroundRemoval = AsyncVideoBackgroundRemoval(self._transport)
+        self.videoBackgroundRemovalFast = AsyncVideoBackgroundRemovalFast(self._transport)
+        self.videoBackgroundRemovalGreenScreen = AsyncVideoBackgroundRemovalGreenScreen(self._transport)
+
+    async def close(self) -> None:
+        await self._transport.close()
+
+    async def __aenter__(self) -> "AsyncVeed":
+        return self
+
+    async def __aexit__(self, *exc_info: object) -> None:
+        await self.close()

veed/resources/__init__.py

@@ -0,0 +1,12 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+
+from .cleanAudio import CleanAudio, AsyncCleanAudio
+from .cleanAudioVideo import CleanAudioVideo, AsyncCleanAudioVideo
+from .dubbing import Dubbing, AsyncDubbing
+from .dubbingPro import DubbingPro, AsyncDubbingPro
+from .fabric import Fabric, AsyncFabric
+from .lipsync20 import Lipsync20, AsyncLipsync20
+from .videoBackgroundRemoval import VideoBackgroundRemoval, AsyncVideoBackgroundRemoval
+from .videoBackgroundRemovalFast import VideoBackgroundRemovalFast, AsyncVideoBackgroundRemovalFast
+from .videoBackgroundRemovalGreenScreen import VideoBackgroundRemovalGreenScreen, AsyncVideoBackgroundRemovalGreenScreen