runapi-seedance 0.1.0__py3-none-any.whl

runapi/seedance/__init__.py

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

runapi/seedance/client.py

@@ -0,0 +1,27 @@
+"""Seedance client."""
+
+from __future__ import annotations
+
+from typing import Any, Optional
+
+from runapi.core import ClientOptions, HttpClient, resolve_api_key
+
+from .resources.text_to_video import TextToVideo
+
+
+class SeedanceClient:
+    """Seedance video generation client.
+
+    Example::
+
+        client = SeedanceClient(api_key="sk-...")
+        result = client.text_to_video.run(
+            model="seedance-2.0", prompt="A cat walking through a garden"
+        )
+    """
+
+    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.text_to_video = TextToVideo(http)

runapi/seedance/contract_gen.py

@@ -0,0 +1,104 @@
+CONTRACT = {
+    "text-to-video": {
+        "models": ["seedance-1.5-pro", "seedance-2.0", "seedance-2.0-fast", "seedance-v1-lite", "seedance-v1-pro", "seedance-v1-pro-fast"],
+        "fields_by_model": {
+            "seedance-1.5-pro": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "4:3", "3:4", "16:9", "9:16", "21:9"]
+                },
+                "duration_seconds": {
+                    "required": True,
+                    "min": 4,
+                    "max": 12,
+                    "type": "integer"
+                },
+                "output_resolution": {
+                    "enum": ["480p", "720p", "1080p"]
+                },
+                "seed": {
+                    "type": "integer"
+                }
+            },
+            "seedance-2.0": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "4:3", "3:4", "16:9", "9:16", "21:9", "auto"]
+                },
+                "duration_seconds": {
+                    "min": 4,
+                    "max": 15,
+                    "type": "integer"
+                },
+                "output_resolution": {
+                    "enum": ["480p", "720p", "1080p"]
+                },
+                "seed": {
+                    "type": "integer"
+                }
+            },
+            "seedance-2.0-fast": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "4:3", "3:4", "16:9", "9:16", "21:9", "auto"]
+                },
+                "duration_seconds": {
+                    "min": 4,
+                    "max": 15,
+                    "type": "integer"
+                },
+                "output_resolution": {
+                    "enum": ["480p", "720p"]
+                },
+                "seed": {
+                    "type": "integer"
+                }
+            },
+            "seedance-v1-lite": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "4:3", "3:4", "16:9", "9:16", "9:21"]
+                },
+                "duration_seconds": {
+                    "enum": [5, 10],
+                    "required": True,
+                    "type": "integer"
+                },
+                "output_resolution": {
+                    "enum": ["480p", "720p", "1080p"]
+                },
+                "seed": {
+                    "type": "integer"
+                }
+            },
+            "seedance-v1-pro": {
+                "aspect_ratio": {
+                    "enum": ["1:1", "4:3", "3:4", "16:9", "9:16", "21:9"]
+                },
+                "duration_seconds": {
+                    "enum": [5, 10],
+                    "required": True,
+                    "type": "integer"
+                },
+                "output_resolution": {
+                    "enum": ["480p", "720p", "1080p"]
+                },
+                "seed": {
+                    "type": "integer"
+                }
+            },
+            "seedance-v1-pro-fast": {
+                "duration_seconds": {
+                    "enum": [5, 10],
+                    "required": True,
+                    "type": "integer"
+                },
+                "first_frame_image_url": {
+                    "required": True
+                },
+                "output_resolution": {
+                    "enum": ["720p", "1080p"]
+                },
+                "seed": {
+                    "type": "integer"
+                }
+            }
+        }
+    }
+}

runapi/seedance/resources/__init__.py

@@ -0,0 +1,3 @@
+from .text_to_video import TextToVideo
+
+__all__ = ["TextToVideo"]

runapi/seedance/resources/text_to_video.py

@@ -0,0 +1,170 @@
+"""Seedance text-to-video resource."""
+
+from __future__ import annotations
+
+from typing import Any, Dict
+
+from runapi.core import Resource, ValidationError
+
+from ..contract_gen import CONTRACT
+from ..types import (
+    FRAME_FIELDS,
+    PROMPT_MAX_LENGTH_1_5,
+    PROMPT_MAX_LENGTH_2,
+    PROMPT_MAX_LENGTH_V1,
+    PROMPT_MIN_LENGTH,
+    REFERENCE_FIELDS,
+    SEED_RANGE,
+    V1_MODELS,
+    CompletedTextToVideoResponse,
+    TextToVideoResponse,
+)
+
+
+class TextToVideo(Resource):
+    """Generate videos from text prompts, images, or reference media."""
+
+    ENDPOINT = "/api/v1/seedance/text_to_video"
+
+    RESPONSE_CLASS = TextToVideoResponse
+    COMPLETED_RESPONSE_CLASS = CompletedTextToVideoResponse
+
+    def run(self, **params: Any) -> Any:
+        """Generate a video and poll until it completes.
+
+        Args:
+            **params: video generation parameters (model, ...).
+
+        Returns:
+            The completed (narrowed) video generation response.
+        """
+        task = self.create(**params)
+        return self._poll_until_complete(lambda: self.get(task.id))
+
+    def create(self, **params: Any) -> Any:
+        """Create a video generation task and return immediately with an id.
+
+        Args:
+            **params: video generation parameters (model, ...).
+
+        Returns:
+            The task creation result with an id.
+        """
+        compacted = self._compact_params(params)
+        self._validate_params(compacted)
+        return self._request("post", self.ENDPOINT, body=compacted)
+
+    def get(self, id: str) -> Any:
+        """Fetch the current status of a video generation task.
+
+        Args:
+            id: The task id returned by ``create``.
+
+        Returns:
+            The current task status.
+        """
+        return self._request("get", f"{self.ENDPOINT}/{id}")
+
+    def _validate_params(self, params: Dict[str, Any]) -> None:
+        prompt = params.get("prompt")
+        if not prompt:
+            raise ValidationError("prompt is required")
+
+        self._validate_contract(CONTRACT["text-to-video"], params)
+
+        model = params.get("model")
+        if model == "seedance-1.5-pro":
+            max_prompt = PROMPT_MAX_LENGTH_1_5
+        elif model in V1_MODELS:
+            max_prompt = PROMPT_MAX_LENGTH_V1
+        else:
+            max_prompt = PROMPT_MAX_LENGTH_2
+        if not (PROMPT_MIN_LENGTH <= len(prompt) <= max_prompt):
+            raise ValidationError(
+                f"prompt length must be between {PROMPT_MIN_LENGTH} and {max_prompt} characters"
+            )
+
+        if model == "seedance-1.5-pro":
+            self._validate_1_5_pro(params)
+        elif model in V1_MODELS:
+            self._validate_v1(params)
+        else:
+            self._validate_2(params)
+
+    def _validate_v1(self, params: Dict[str, Any]) -> None:
+        model = params.get("model")
+        has_image = self._field_present(params, "first_frame_image_url")
+
+        if has_image and self._field_present(params, "aspect_ratio"):
+            raise ValidationError(
+                "aspect_ratio is not accepted in image-to-video mode; it is derived from the image"
+            )
+
+        if self._field_present(params, "last_frame_image_url") and not (
+            model == "seedance-v1-lite" and has_image
+        ):
+            raise ValidationError(
+                "last_frame_image_url is only supported by seedance-v1-lite in image-to-video mode"
+            )
+
+        unsupported = [
+            "source_image_urls",
+            "reference_image_urls",
+            "reference_video_urls",
+            "reference_audio_urls",
+            "web_search",
+            "generate_audio",
+        ]
+        self._reject_unsupported(params, unsupported, model)
+
+        if model == "seedance-v1-pro-fast":
+            self._reject_unsupported(params, ["lock_camera", "seed"], model)
+
+        seed = params.get("seed")
+        if seed is not None:
+            if not (isinstance(seed, int) and not isinstance(seed, bool) and seed in SEED_RANGE):
+                raise ValidationError(
+                    f"seed must be an integer between {SEED_RANGE.start} and {SEED_RANGE.stop - 1}"
+                )
+
+    def _validate_1_5_pro(self, params: Dict[str, Any]) -> None:
+        value = params.get("source_image_urls")
+        if isinstance(value, list) and len(value) > 2:
+            raise ValidationError("source_image_urls accepts at most 2 images for seedance-1.5-pro")
+
+        unsupported = [
+            "first_frame_image_url",
+            "last_frame_image_url",
+            "reference_image_urls",
+            "reference_video_urls",
+            "reference_audio_urls",
+            "web_search",
+        ]
+        self._reject_unsupported(params, unsupported, "seedance-1.5-pro")
+
+    def _validate_2(self, params: Dict[str, Any]) -> None:
+        unsupported = ["source_image_urls", "lock_camera"]
+        self._reject_unsupported(params, unsupported, params.get("model"))
+
+        self._validate_mode_conflicts(params)
+
+    def _validate_mode_conflicts(self, params: Dict[str, Any]) -> None:
+        has_frame = any(self._field_present(params, f) for f in FRAME_FIELDS)
+        has_reference = any(self._field_present(params, f) for f in REFERENCE_FIELDS)
+
+        if has_frame and has_reference:
+            raise ValidationError("Cannot use frame mode and reference mode at the same time")
+
+    def _reject_unsupported(self, params: Dict[str, Any], fields: Any, model: Any) -> None:
+        for field in fields:
+            if self._field_present(params, field):
+                raise ValidationError(f"{field} is not supported for {model}")
+
+    @staticmethod
+    def _field_present(params: Dict[str, Any], key: str) -> bool:
+        value = params.get(key)
+        if value is None:
+            return False
+        if hasattr(value, "__len__"):
+            return len(value) > 0
+        return True

runapi/seedance/types.py

@@ -0,0 +1,42 @@
+"""Seedance model lists, enums, and response models."""
+
+from __future__ import annotations
+
+from runapi.core import BaseModel, TaskResponse, optional, required
+
+V1_MODELS = ["seedance-v1-lite", "seedance-v1-pro", "seedance-v1-pro-fast"]
+
+SEED_RANGE = range(-1, 2_147_483_648)
+
+PROMPT_MIN_LENGTH = 3
+PROMPT_MAX_LENGTH_1_5 = 2500
+PROMPT_MAX_LENGTH_2 = 20000
+PROMPT_MAX_LENGTH_V1 = 10000
+
+FRAME_FIELDS = ["first_frame_image_url", "last_frame_image_url"]
+REFERENCE_FIELDS = ["reference_image_urls", "reference_video_urls", "reference_audio_urls"]
+
+
+class Video(BaseModel):
+    url = optional(str)
+
+
+class AsyncTaskResponse(TaskResponse):
+    """Seedance async task status response."""
+
+    id = required(str)
+    status = optional(str, enum=lambda: TaskResponse.Status.ALL)
+
+
+class TextToVideoResponse(AsyncTaskResponse):
+    """Seedance video generation task status response."""
+
+    videos = optional([lambda: Video])
+    last_frame_image_url = optional(str)
+    error = optional(str)
+
+
+class CompletedTextToVideoResponse(TextToVideoResponse):
+    """Narrowed response from ``run()`` once polling observes completion."""
+
+    videos = required([lambda: Video])

runapi_seedance-0.1.0.dist-info/METADATA

@@ -0,0 +1,81 @@
+Metadata-Version: 2.4
+Name: runapi-seedance
+Version: 0.1.0
+Summary: Seedance video generation client for RunAPI
+Project-URL: Homepage, https://runapi.ai/models/seedance
+Project-URL: Documentation, https://runapi.ai/docs#sdk-seedance
+Author-email: RunAPI <contact@runapi.ai>
+License-Expression: Apache-2.0
+Keywords: ai,runapi,sdk,seedance,text-to-video,video
+Requires-Python: >=3.9
+Requires-Dist: runapi-core
+Description-Content-Type: text/markdown
+
+# Seedance Python SDK for RunAPI
+
+The Seedance Python SDK is the language-specific package for Seedance on RunAPI.
+Use it for text-to-video, image-to-video, and reference-media flows when your
+application needs JSON request bodies, task status lookup, and consistent RunAPI
+errors in Python.
+
+For model details, use https://runapi.ai/models/seedance; for API reference, use
+https://runapi.ai/docs#seedance; for SDK docs, use https://runapi.ai/docs#sdk-seedance.
+
+## Install
+
+```bash
+pip install runapi-seedance
+```
+
+## Quick start
+
+```python
+from runapi.seedance import SeedanceClient
+
+client = SeedanceClient()  # reads RUNAPI_API_KEY, or pass api_key="sk-..."
+
+task = client.text_to_video.create(
+    model="seedance-2.0",
+    prompt="A cat walking through a garden",
+    duration_seconds=8,
+)
+status = client.text_to_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.text_to_video.run(
+    model="seedance-2.0",
+    prompt="A cinematic drone shot over snowy mountains",
+    duration_seconds=8,
+)
+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.seedance` error
+classes when building video jobs or scripts. The available resource is
+`text_to_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/seedance
+- SDK docs: https://runapi.ai/docs#sdk-seedance
+- Product docs: https://runapi.ai/docs#seedance
+- Pricing and rate limits: https://runapi.ai/models/seedance
+- Full catalog: https://runapi.ai/models
+
+## License
+
+Licensed under the Apache License, Version 2.0.

runapi_seedance-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+runapi/seedance/__init__.py,sha256=0bh7ZtuByL32-02Gx0KANL1mS9q_cKDw_rxcgCithmM,466
+runapi/seedance/client.py,sha256=vewixJ3DDyl2nP6Sxvk3KRXJyvs2cbalFrS7NcxpH70,804
+runapi/seedance/contract_gen.py,sha256=E-OpP82IuFqgEbhpfX_5_volT3nhcdx-m3n9uRB0Yb4,3429
+runapi/seedance/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+runapi/seedance/types.py,sha256=_-FDrC-ZP7_SbuEJM9AFWJRGdFvRdJvxmnz0BnIK3Dw,1160
+runapi/seedance/resources/__init__.py,sha256=1T9dH_XTn-pM1F5Kt2H-yZiLOWM8_sFTJXUXEmgyjkU,66
+runapi/seedance/resources/text_to_video.py,sha256=CSpfWMbkFOsSoTP4AoB7zKuIIhccfglJu_owq9wP8-E,5866
+runapi_seedance-0.1.0.dist-info/METADATA,sha256=7y9npS4lJ_sJHR3uk2p8Mk6S4y22jg905ZelPp4JImw,2503
+runapi_seedance-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+runapi_seedance-0.1.0.dist-info/RECORD,,

runapi_seedance-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