veed 0.1.0__tar.gz

veed-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+uv.lock
+.venv/
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/

veed-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Veed Limited
+
+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.

veed-0.1.0/PKG-INFO

@@ -0,0 +1,94 @@
+Metadata-Version: 2.5
+Name: veed
+Version: 0.1.0
+Summary: Official Python SDK for the VEED API
+Project-URL: Homepage, https://veed.io
+Project-URL: Repository, https://github.com/veedstudio/veed-sdk-python
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.9
+Requires-Dist: httpx<1,>=0.27
+Requires-Dist: pydantic<3,>=2.0
+Description-Content-Type: text/markdown
+
+# veed
+
+Official Python SDK for the [VEED API](https://api.veed.io) — programmatic access to VEED's AI video models.
+
+> Generated from VEED's OpenAPI spec. Do not edit by hand — changes are overwritten on the next release.
+
+## Install
+
+```bash
+pip install veed
+```
+
+## Usage
+
+```python
+import veed
+
+client = veed.Veed()  # reads VEED_API_KEY
+
+# One-shot: submit and wait for the finished video.
+job = client.fabric.generate(
+    image_url="https://example.com/face.png",
+    audio_url="https://example.com/speech.mp3",
+    resolution="720p",
+)
+print(job.result.video.url)
+```
+
+Or keep control of the lifecycle:
+
+```python
+job = client.lipsync20.submit(
+    video_url="https://example.com/source.mp4",
+    audio_url="https://example.com/dub.mp3",
+)
+# ... persist job.job_id, come back later ...
+job = client.lipsync20.wait(job.job_id, poll_interval=5.0, timeout=1800.0)
+```
+
+### Async
+
+```python
+async with veed.AsyncVeed() as client:
+    job = await client.fabric.generate(
+        image_url="https://example.com/face.png",
+        audio_url="https://example.com/speech.mp3",
+        resolution="720p",
+    )
+```
+
+### Errors
+
+HTTP-layer rejections raise subclasses of `veed.APIError` (with `.status_code`, `.code`,
+`.request_id`). Accepted jobs that fail during rendering raise `veed.JobFailedError` from
+`wait`/`generate`, with the model-specific failure code:
+
+```python
+try:
+    job = client.fabric.generate(...)
+except veed.JobFailedError as e:
+    if e.code == veed.FabricJobErrorCode.CONTENT_MODERATION:
+        ...  # handle moderation rejection
+```
+
+Retries (429/5xx, honoring `Retry-After`) are built in; submits are safe to retry because a
+rejected submit never creates a job.
+
+## Development
+
+This SDK is generated, so fixes belong upstream rather than here — but to reproduce something
+locally you need only [uv](https://docs.astral.sh/uv/), which fetches the interpreter pinned in
+`.python-version` for you:
+
+```bash
+uv sync
+uv run python -m unittest discover -s tests
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

veed-0.1.0/README.md

@@ -0,0 +1,81 @@
+# veed
+
+Official Python SDK for the [VEED API](https://api.veed.io) — programmatic access to VEED's AI video models.
+
+> Generated from VEED's OpenAPI spec. Do not edit by hand — changes are overwritten on the next release.
+
+## Install
+
+```bash
+pip install veed
+```
+
+## Usage
+
+```python
+import veed
+
+client = veed.Veed()  # reads VEED_API_KEY
+
+# One-shot: submit and wait for the finished video.
+job = client.fabric.generate(
+    image_url="https://example.com/face.png",
+    audio_url="https://example.com/speech.mp3",
+    resolution="720p",
+)
+print(job.result.video.url)
+```
+
+Or keep control of the lifecycle:
+
+```python
+job = client.lipsync20.submit(
+    video_url="https://example.com/source.mp4",
+    audio_url="https://example.com/dub.mp3",
+)
+# ... persist job.job_id, come back later ...
+job = client.lipsync20.wait(job.job_id, poll_interval=5.0, timeout=1800.0)
+```
+
+### Async
+
+```python
+async with veed.AsyncVeed() as client:
+    job = await client.fabric.generate(
+        image_url="https://example.com/face.png",
+        audio_url="https://example.com/speech.mp3",
+        resolution="720p",
+    )
+```
+
+### Errors
+
+HTTP-layer rejections raise subclasses of `veed.APIError` (with `.status_code`, `.code`,
+`.request_id`). Accepted jobs that fail during rendering raise `veed.JobFailedError` from
+`wait`/`generate`, with the model-specific failure code:
+
+```python
+try:
+    job = client.fabric.generate(...)
+except veed.JobFailedError as e:
+    if e.code == veed.FabricJobErrorCode.CONTENT_MODERATION:
+        ...  # handle moderation rejection
+```
+
+Retries (429/5xx, honoring `Retry-After`) are built in; submits are safe to retry because a
+rejected submit never creates a job.
+
+## Development
+
+This SDK is generated, so fixes belong upstream rather than here — but to reproduce something
+locally you need only [uv](https://docs.astral.sh/uv/), which fetches the interpreter pinned in
+`.python-version` for you:
+
+```bash
+uv sync
+uv run python -m unittest discover -s tests
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

veed-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+# Code generated from the VEED OpenAPI spec. DO NOT EDIT.
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "veed"
+version = "0.1.0"
+description = "Official Python SDK for the VEED API"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "MIT"
+license-files = ["LICENSE"]
+dependencies = [
+    "httpx>=0.27,<1",
+    "pydantic>=2.0,<3",
+]
+
+[project.urls]
+Homepage = "https://veed.io"
+Repository = "https://github.com/veedstudio/veed-sdk-python"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/veed"]
+
+# hatchling ships the whole tree by default, which put .github/workflows on
+# PyPI. (.gitignore lands there regardless of this list.)
+[tool.hatch.build.targets.sdist]
+include = ["src/veed", "tests", "README.md", "LICENSE", "pyproject.toml"]

veed-0.1.0/src/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-0.1.0/src/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)"
+        )