runapi-runway-aleph 0.1.0__tar.gz

runapi_runway_aleph-0.1.0/.gitignore

@@ -0,0 +1,29 @@
+# Build artifacts
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Bytecode
+__pycache__/
+*.py[cod]
+
+# Virtual environments
+.venv/
+venv/
+
+# uv
+uv.lock
+
+# Test / type caches
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+.coverage
+htmlcov/
+
+# IDE / OS
+.idea/
+.vscode/
+*.swp
+.DS_Store

runapi_runway_aleph-0.1.0/PKG-INFO

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: runapi-runway-aleph
+Version: 0.1.0
+Summary: Runway Aleph prompt-guided video editing client for RunAPI
+Project-URL: Homepage, https://runapi.ai/models/runway-aleph
+Project-URL: Documentation, https://runapi.ai/docs#sdk-runway-aleph
+Author-email: RunAPI <contact@runapi.ai>
+License-Expression: Apache-2.0
+Keywords: ai,runapi,runway,runway-aleph,sdk,video
+Requires-Python: >=3.9
+Requires-Dist: runapi-core
+Description-Content-Type: text/markdown
+
+# Runway Aleph Python SDK for RunAPI
+
+The Runway Aleph Python SDK is the language-specific package for Runway Aleph on
+RunAPI. Use it for prompt-guided video editing when your application needs JSON
+request bodies, task status lookup, and consistent RunAPI errors in Python.
+
+For model details, use https://runapi.ai/models/runway-aleph; for API reference,
+use https://runapi.ai/docs#runway-aleph; for SDK docs, use
+https://runapi.ai/docs#sdk-runway-aleph.
+
+## Install
+
+```bash
+pip install runapi-runway-aleph
+```
+
+## Quick start
+
+```python
+from runapi.runway_aleph import RunwayAlephClient
+
+client = RunwayAlephClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+task = client.edit_video.create(
+    model="runway-aleph",
+    prompt="Transform the scene into a watercolor painting style",
+    source_video_url="https://cdn.runapi.ai/public/samples/video.mp4",
+)
+status = client.edit_video.get(task.id)
+```
+
+Use `create` to submit a task and return quickly, `get` to fetch the latest task
+state, and `run` to create and poll until completion:
+
+```python
+result = client.edit_video.run(
+    model="runway-aleph",
+    prompt="Transform the scene into a watercolor painting style",
+    source_video_url="https://cdn.runapi.ai/public/samples/video.mp4",
+)
+print(result.videos[0].url)
+```
+
+In web request handlers, prefer `create` plus webhook or later `get` polling so a
+worker is not held open.
+
+RunAPI-generated file URLs are temporary. Download and store generated videos in
+your own durable storage within 7 days; do not treat returned URLs as long-term
+assets.
+
+## Language notes
+
+Pass parameters as keyword arguments and catch the `runapi.runway_aleph` error
+classes when building video jobs, workers, or scripts. The available resource is
+`edit_video`. Keep `RUNAPI_API_KEY` in the environment or your secret manager;
+never commit API keys or callback secrets.
+
+## Links
+
+- Model page: https://runapi.ai/models/runway-aleph
+- SDK docs: https://runapi.ai/docs#sdk-runway-aleph
+- Product docs: https://runapi.ai/docs#runway-aleph
+- Pricing and rate limits: https://runapi.ai/models/runway-aleph
+- Full catalog: https://runapi.ai/models
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_runway_aleph-0.1.0/README.md

@@ -0,0 +1,68 @@
+# Runway Aleph Python SDK for RunAPI
+
+The Runway Aleph Python SDK is the language-specific package for Runway Aleph on
+RunAPI. Use it for prompt-guided video editing when your application needs JSON
+request bodies, task status lookup, and consistent RunAPI errors in Python.
+
+For model details, use https://runapi.ai/models/runway-aleph; for API reference,
+use https://runapi.ai/docs#runway-aleph; for SDK docs, use
+https://runapi.ai/docs#sdk-runway-aleph.
+
+## Install
+
+```bash
+pip install runapi-runway-aleph
+```
+
+## Quick start
+
+```python
+from runapi.runway_aleph import RunwayAlephClient
+
+client = RunwayAlephClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+task = client.edit_video.create(
+    model="runway-aleph",
+    prompt="Transform the scene into a watercolor painting style",
+    source_video_url="https://cdn.runapi.ai/public/samples/video.mp4",
+)
+status = client.edit_video.get(task.id)
+```
+
+Use `create` to submit a task and return quickly, `get` to fetch the latest task
+state, and `run` to create and poll until completion:
+
+```python
+result = client.edit_video.run(
+    model="runway-aleph",
+    prompt="Transform the scene into a watercolor painting style",
+    source_video_url="https://cdn.runapi.ai/public/samples/video.mp4",
+)
+print(result.videos[0].url)
+```
+
+In web request handlers, prefer `create` plus webhook or later `get` polling so a
+worker is not held open.
+
+RunAPI-generated file URLs are temporary. Download and store generated videos in
+your own durable storage within 7 days; do not treat returned URLs as long-term
+assets.
+
+## Language notes
+
+Pass parameters as keyword arguments and catch the `runapi.runway_aleph` error
+classes when building video jobs, workers, or scripts. The available resource is
+`edit_video`. Keep `RUNAPI_API_KEY` in the environment or your secret manager;
+never commit API keys or callback secrets.
+
+## Links
+
+- Model page: https://runapi.ai/models/runway-aleph
+- SDK docs: https://runapi.ai/docs#sdk-runway-aleph
+- Product docs: https://runapi.ai/docs#runway-aleph
+- Pricing and rate limits: https://runapi.ai/models/runway-aleph
+- Full catalog: https://runapi.ai/models
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_runway_aleph-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "runapi-runway-aleph"
+version = "0.1.0"
+description = "Runway Aleph prompt-guided video editing client for RunAPI"
+readme = "README.md"
+requires-python = ">=3.9"
+license = "Apache-2.0"
+authors = [{ name = "RunAPI", email = "contact@runapi.ai" }]
+keywords = ["runapi", "runway", "runway-aleph", "video", "ai", "sdk"]
+dependencies = ["runapi-core"]
+
+[project.urls]
+Homepage = "https://runapi.ai/models/runway-aleph"
+Documentation = "https://runapi.ai/docs#sdk-runway-aleph"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/runapi"]
+
+[tool.uv]
+package = true
+
+[tool.uv.sources]
+runapi-core = { workspace = true }
+
+[dependency-groups]
+dev = ["pytest>=8"]
+
+[tool.runapi]
+slug = "runway-aleph"

runapi_runway_aleph-0.1.0/src/runapi/runway_aleph/__init__.py

@@ -0,0 +1,24 @@
+"""Runway Aleph client for RunAPI."""
+
+from runapi.core import (
+    AuthenticationError,
+    InsufficientCreditsError,
+    NotFoundError,
+    RateLimitError,
+    TaskFailedError,
+    TaskTimeoutError,
+    ValidationError,
+)
+
+from .client import RunwayAlephClient
+
+__all__ = [
+    "RunwayAlephClient",
+    "AuthenticationError",
+    "RateLimitError",
+    "InsufficientCreditsError",
+    "NotFoundError",
+    "ValidationError",
+    "TaskFailedError",
+    "TaskTimeoutError",
+]

runapi_runway_aleph-0.1.0/src/runapi/runway_aleph/client.py

@@ -0,0 +1,29 @@
+"""Runway Aleph client."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from runapi.core import ClientOptions, HttpClient, resolve_api_key
+
+from .resources.edit_video import EditVideo
+
+
+class RunwayAlephClient:
+    """Runway Aleph prompt-guided video editing client.
+
+    Example::
+
+        client = RunwayAlephClient(api_key="sk-...")
+        result = client.edit_video.run(
+            model="runway-aleph",
+            prompt="Transform the scene into a watercolor painting style",
+            source_video_url="https://cdn.runapi.ai/public/samples/video.mp4",
+        )
+    """
+
+    def __init__(self, api_key: Optional[str] = None, **options: Any) -> None:
+        resolved_api_key = resolve_api_key(api_key)
+        client_options = ClientOptions(api_key=resolved_api_key, **options)
+        http = client_options.http_client or HttpClient(client_options)
+        self.edit_video = EditVideo(http)

runapi_runway_aleph-0.1.0/src/runapi/runway_aleph/contract_gen.py

@@ -0,0 +1,21 @@
+CONTRACT = {
+    "edit-video": {
+        "models": ["runway-aleph"],
+        "fields_by_model": {
+            "runway-aleph": {
+                "aspect_ratio": {
+                    "enum": ["16:9", "9:16", "4:3", "3:4", "1:1", "21:9"]
+                },
+                "prompt": {
+                    "required": True
+                },
+                "seed": {
+                    "type": "integer"
+                },
+                "source_video_url": {
+                    "required": True
+                }
+            }
+        }
+    }
+}

runapi_runway_aleph-0.1.0/src/runapi/runway_aleph/resources/__init__.py

@@ -0,0 +1,3 @@
+from .edit_video import EditVideo
+
+__all__ = ["EditVideo"]

runapi_runway_aleph-0.1.0/src/runapi/runway_aleph/resources/edit_video.py

@@ -0,0 +1,39 @@
+"""Runway Aleph edit-video resource."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from runapi.core import Resource
+
+from ..contract_gen import CONTRACT
+from ..types import (
+    CompletedEditVideoResponse,
+    TaskCreateResponse,
+)
+
+
+class EditVideo(Resource):
+    """Prompt-guided video editing with Runway Aleph."""
+
+    ENDPOINT = "/api/v1/runway_aleph/edit_video"
+
+    RESPONSE_CLASS = TaskCreateResponse
+    COMPLETED_RESPONSE_CLASS = CompletedEditVideoResponse
+
+    MODEL = "runway-aleph"
+
+    def run(self, **params: Any) -> Any:
+        """Create a task and poll until it completes."""
+        task = self.create(**params)
+        return self._poll_until_complete(lambda: self.get(task.id))
+
+    def create(self, **params: Any) -> Any:
+        """Create an edit-video task and return immediately with an ``id``."""
+        compacted = self._compact_params(params)
+        self._validate_contract(CONTRACT["edit-video"], {**compacted, "model": self.MODEL})
+        return self._request("post", self.ENDPOINT, body=compacted)
+
+    def get(self, id: str) -> Any:
+        """Fetch the current status of an edit-video task."""
+        return self._request("get", f"{self.ENDPOINT}/{id}")

runapi_runway_aleph-0.1.0/src/runapi/runway_aleph/types.py

@@ -0,0 +1,37 @@
+"""Runway Aleph enums and response models."""
+
+from __future__ import annotations
+
+from runapi.core import BaseModel, TaskResponse, optional, required
+
+
+class Video(BaseModel):
+    id = optional(str)
+    url = required(str)
+
+
+class Image(BaseModel):
+    url = required(str)
+
+
+class EditVideoResponse(TaskResponse):
+    """Runway Aleph video editing task status response."""
+
+    id = required(str)
+    status = optional(str, enum=lambda: TaskResponse.Status.ALL)
+    videos = optional([lambda: Video])
+    images = optional([lambda: Image])
+    error = optional(str)
+
+
+class TaskCreateResponse(EditVideoResponse):
+    """Runway Aleph task creation response with an id."""
+
+
+class CompletedEditVideoResponse(EditVideoResponse):
+    """Returned by ``edit_video.run()`` once polling observes completion.
+
+    ``videos`` is required so callers never have to null-check it on success.
+    """
+
+    videos = required([lambda: Video])

runapi_runway_aleph-0.1.0/tests/test_client.py

@@ -0,0 +1,161 @@
+import pytest
+
+from runapi.core import config
+from runapi.core.errors import AuthenticationError, ValidationError
+from runapi.runway_aleph import RunwayAlephClient
+from runapi.runway_aleph.resources.edit_video import EditVideo
+from runapi.runway_aleph.types import CompletedEditVideoResponse, EditVideoResponse
+
+
+class FakeHttp:
+    """Records (method, path, body) and replays preset responses by call order."""
+
+    def __init__(self, *responses):
+        self._responses = list(responses)
+        self.calls = []
+
+    def request(self, method, path, body=None, options=None):
+        self.calls.append((method, path, body))
+        if self._responses:
+            return self._responses.pop(0)
+        return {"id": "task_1", "status": "pending"}
+
+
+@pytest.fixture(autouse=True)
+def reset_config(monkeypatch):
+    monkeypatch.delenv("RUNAPI_API_KEY", raising=False)
+    monkeypatch.setattr(config, "api_key", None)
+    yield
+
+
+# --- authentication -------------------------------------------------------
+
+
+def test_accepts_api_key_parameter():
+    assert isinstance(
+        RunwayAlephClient(api_key="param-key", http_client=FakeHttp()), RunwayAlephClient
+    )
+
+
+def test_falls_back_to_global(monkeypatch):
+    monkeypatch.setattr(config, "api_key", "global-key")
+    assert isinstance(RunwayAlephClient(http_client=FakeHttp()), RunwayAlephClient)
+
+
+def test_falls_back_to_env(monkeypatch):
+    monkeypatch.setenv("RUNAPI_API_KEY", "env-key")
+    assert isinstance(RunwayAlephClient(http_client=FakeHttp()), RunwayAlephClient)
+
+
+def test_raises_without_api_key():
+    with pytest.raises(AuthenticationError, match="API key is required"):
+        RunwayAlephClient()
+
+
+# --- transport injection / accessors --------------------------------------
+
+
+def test_uses_injected_http_client():
+    fake = FakeHttp()
+    client = RunwayAlephClient(api_key="k", http_client=fake)
+    assert client.edit_video._http is fake
+
+
+def test_exposes_resource_accessors():
+    client = RunwayAlephClient(api_key="k", http_client=FakeHttp())
+    assert isinstance(client.edit_video, EditVideo)
+
+
+# --- request shapes -------------------------------------------------------
+
+
+def test_create_posts_compacted_body():
+    fake = FakeHttp({"id": "t1", "status": "pending"})
+    client = RunwayAlephClient(api_key="k", http_client=fake)
+    result = client.edit_video.create(
+        prompt="hello",
+        source_video_url="https://example.com/v.mp4",
+        aspect_ratio="16:9",
+        seed=None,
+    )
+    assert fake.calls == [
+        (
+            "post",
+            "/api/v1/runway_aleph/edit_video",
+            {
+                "prompt": "hello",
+                "source_video_url": "https://example.com/v.mp4",
+                "aspect_ratio": "16:9",
+            },
+        ),
+    ]
+    _, _, body = fake.calls[0]
+    assert "model" not in body
+    assert isinstance(result, EditVideoResponse)
+    assert result.id == "t1"
+
+
+def test_get_fetches_by_id():
+    fake = FakeHttp({"id": "t1", "status": "processing"})
+    client = RunwayAlephClient(api_key="k", http_client=fake)
+    client.edit_video.get("t1")
+    assert fake.calls == [("get", "/api/v1/runway_aleph/edit_video/t1", None)]
+
+
+def test_run_polls_and_narrows_completed_type():
+    fake = FakeHttp(
+        {"id": "t1", "status": "pending"},
+        {"id": "t1", "status": "completed", "videos": [{"url": "https://x/y.mp4"}]},
+    )
+    client = RunwayAlephClient(api_key="k", http_client=fake)
+    result = client.edit_video.run(
+        model="runway-aleph",
+        prompt="hi",
+        source_video_url="https://example.com/v.mp4",
+    )
+
+    assert isinstance(result, CompletedEditVideoResponse)
+    assert result.videos[0].url == "https://x/y.mp4"
+    assert [call[0] for call in fake.calls] == ["post", "get"]
+
+
+# --- validation -----------------------------------------------------------
+
+
+def test_create_requires_prompt():
+    client = RunwayAlephClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="prompt is required"):
+        client.edit_video.create(
+            model="runway-aleph", source_video_url="https://example.com/v.mp4"
+        )
+
+
+def test_create_requires_source_video_url():
+    client = RunwayAlephClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="source_video_url is required"):
+        client.edit_video.create(model="runway-aleph", prompt="hi")
+
+
+def test_create_rejects_invalid_aspect_ratio():
+    client = RunwayAlephClient(api_key="k", http_client=FakeHttp())
+    with pytest.raises(ValidationError, match="aspect_ratio must be one of"):
+        client.edit_video.create(
+            model="runway-aleph",
+            prompt="hi",
+            source_video_url="https://example.com/v.mp4",
+            aspect_ratio="99:1",
+        )
+
+
+def test_create_accepts_valid_aspect_ratio():
+    fake = FakeHttp({"id": "t1", "status": "pending"})
+    client = RunwayAlephClient(api_key="k", http_client=fake)
+    client.edit_video.create(
+        model="runway-aleph",
+        prompt="hi",
+        source_video_url="https://example.com/v.mp4",
+        aspect_ratio="21:9",
+    )
+    _, path, body = fake.calls[0]
+    assert path == "/api/v1/runway_aleph/edit_video"
+    assert body["aspect_ratio"] == "21:9"