movoa 0.1.0__tar.gz

movoa-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Movoa (https://movoa.ai)
+
+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.

movoa-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: movoa
+Version: 0.1.0
+Summary: Unlimited AI video generator with sound: on paid plans the tenth take of a shot costs what the first did, and your first clip is free to make right now. Official Python SDK for Movoa (movoa.ai): text to video and photo to video with sound from your own code.
+Author: Movoa (https://movoa.ai)
+License: MIT
+Project-URL: Homepage, https://movoa.ai/?utm_source=pypi&utm_medium=package
+Project-URL: Text to video, https://movoa.ai/video/text-to-video
+Project-URL: API keys, https://movoa.ai/settings/apikeys
+Project-URL: Pricing, https://movoa.ai/pricing
+Project-URL: Source, https://github.com/hanshs474/movoa-py
+Keywords: ai,video-generation,ai-video-generator,text-to-video,image-to-video,photo-to-video,ai-video-with-audio,minimax-h3,seedance-2-5,veo-3,movoa
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# movoa
+
+Unlimited AI video generator with sound: on paid plans the tenth take of a shot costs what the first did, and your first clip is free to make right now. This is the official Python SDK for [Movoa](https://movoa.ai/?utm_source=pypi&utm_medium=package): one API key turns a prompt into [text to video](https://movoa.ai/video/text-to-video), or a still into [photo to video](https://movoa.ai/video/photo-to-video), and every clip comes back as [AI video with audio](https://movoa.ai/video/ai-video-with-audio).
+
+```bash
+pip install movoa
+```
+
+```python
+from movoa import generate_video
+
+clip = generate_video("a paper boat drifting down a rain gutter, low angle, slow push-in")
+print(clip)  # URL of the finished MP4, sound included
+```
+
+Standard library only, no dependencies. `generate_video` submits the run, waits for it and returns the URL of the finished file.
+
+## API key
+
+Sign in on [movoa.ai](https://movoa.ai/?utm_source=pypi&utm_medium=package), create a key at [movoa.ai/settings/apikeys](https://movoa.ai/settings/apikeys), then pass it as `api_key=` or export it:
+
+```bash
+export MOVOA_API_KEY=sk-...
+```
+
+Runs cost credits on your Movoa account, at the prices on [movoa.ai/pricing](https://movoa.ai/pricing).
+
+```python
+from movoa import credits
+print(credits())  # remaining credits on the account
+```
+
+## Text to video and photo to video
+
+```python
+from movoa import generate_video
+
+# text to video, vertical, 10 seconds
+generate_video("a fox trotting through fresh snow at dawn, tracking shot",
+               duration=10, aspect_ratio="9:16")
+
+# photo to video: the photo becomes the first frame
+generate_video("the camera slowly orbits the statue", image_url="https://example.com/statue.jpg")
+
+# another model
+generate_video("a street drummer in the rain, close-up", model="seedance-2-5", duration=10, resolution="720p")
+```
+
+| model | options |
+|---|---|
+| `minimax-h3` (default) | `duration` 4 / 5 / 6 / 8 / 10 / 15 · `resolution` 480p / 768p · `aspect_ratio` 16:9 / 9:16 / 1:1 |
+| `veo-3-1-fast` | `duration` 8 · `resolution` 720p · `aspect_ratio` 16:9 / 9:16 (photo to video: 16:9) |
+| `seedance-2-5` | `duration` 5 / 10 / 15 / 20 / 25 / 30 · `resolution` 480p / 720p · `aspect_ratio` 16:9 / 9:16 / 1:1 |
+| `seedance-2`, `seedance-2-fast`, `seedance-2-mini` | `duration` 4 / 6 / 8 / 10 · `resolution` 480p / 720p · `aspect_ratio` |
+
+Any extra keyword argument is sent in `options` as it is. Every run asks for sound. On the site: [Seedance 2.5](https://movoa.ai/video/seedance-2-5) and [Veo 3](https://movoa.ai/video/google-veo-3).
+
+## Submit now, collect later
+
+```python
+from movoa import submit, status, wait
+
+task_id = submit("a lighthouse in a storm, waves crashing", "minimax-h3", duration=6)
+print(status(task_id)["status"])  # pending | processing | success | failed | canceled
+url = wait(task_id)               # polls every 10 seconds, 30 minutes by default
+```
+
+While a run waits in line, `status()` returns `queued: True` and `queueEta` in seconds.
+
+## Errors worth catching
+
+Each failure is its own subclass of `MovoaError`, so you can branch on what to do next:
+
+- `AuthError`: no key, or the key is wrong or deleted; create one at [movoa.ai/settings/apikeys](https://movoa.ai/settings/apikeys)
+- `QuotaError`: the account does not have enough credits for this run
+- `PlanError`: that model or quality needs a plan on the account
+- `BusyError`: too many runs on this account are generating at once
+- `RejectedError`: the content filter refused the prompt, or a cooldown is active; reword it
+- `GenerationError`: the run was accepted but failed or was canceled; `.error_message` says why
+- `TimeoutError`: the wait ran out; `.task_id` lets you check the run later with `status()`
+
+Any other refusal raises `MovoaError` with the server's message.
+
+MIT licensed. Made by [Movoa](https://movoa.ai/?utm_source=pypi&utm_medium=package).

movoa-0.1.0/README.md

@@ -0,0 +1,84 @@
+# movoa
+
+Unlimited AI video generator with sound: on paid plans the tenth take of a shot costs what the first did, and your first clip is free to make right now. This is the official Python SDK for [Movoa](https://movoa.ai/?utm_source=pypi&utm_medium=package): one API key turns a prompt into [text to video](https://movoa.ai/video/text-to-video), or a still into [photo to video](https://movoa.ai/video/photo-to-video), and every clip comes back as [AI video with audio](https://movoa.ai/video/ai-video-with-audio).
+
+```bash
+pip install movoa
+```
+
+```python
+from movoa import generate_video
+
+clip = generate_video("a paper boat drifting down a rain gutter, low angle, slow push-in")
+print(clip)  # URL of the finished MP4, sound included
+```
+
+Standard library only, no dependencies. `generate_video` submits the run, waits for it and returns the URL of the finished file.
+
+## API key
+
+Sign in on [movoa.ai](https://movoa.ai/?utm_source=pypi&utm_medium=package), create a key at [movoa.ai/settings/apikeys](https://movoa.ai/settings/apikeys), then pass it as `api_key=` or export it:
+
+```bash
+export MOVOA_API_KEY=sk-...
+```
+
+Runs cost credits on your Movoa account, at the prices on [movoa.ai/pricing](https://movoa.ai/pricing).
+
+```python
+from movoa import credits
+print(credits())  # remaining credits on the account
+```
+
+## Text to video and photo to video
+
+```python
+from movoa import generate_video
+
+# text to video, vertical, 10 seconds
+generate_video("a fox trotting through fresh snow at dawn, tracking shot",
+               duration=10, aspect_ratio="9:16")
+
+# photo to video: the photo becomes the first frame
+generate_video("the camera slowly orbits the statue", image_url="https://example.com/statue.jpg")
+
+# another model
+generate_video("a street drummer in the rain, close-up", model="seedance-2-5", duration=10, resolution="720p")
+```
+
+| model | options |
+|---|---|
+| `minimax-h3` (default) | `duration` 4 / 5 / 6 / 8 / 10 / 15 · `resolution` 480p / 768p · `aspect_ratio` 16:9 / 9:16 / 1:1 |
+| `veo-3-1-fast` | `duration` 8 · `resolution` 720p · `aspect_ratio` 16:9 / 9:16 (photo to video: 16:9) |
+| `seedance-2-5` | `duration` 5 / 10 / 15 / 20 / 25 / 30 · `resolution` 480p / 720p · `aspect_ratio` 16:9 / 9:16 / 1:1 |
+| `seedance-2`, `seedance-2-fast`, `seedance-2-mini` | `duration` 4 / 6 / 8 / 10 · `resolution` 480p / 720p · `aspect_ratio` |
+
+Any extra keyword argument is sent in `options` as it is. Every run asks for sound. On the site: [Seedance 2.5](https://movoa.ai/video/seedance-2-5) and [Veo 3](https://movoa.ai/video/google-veo-3).
+
+## Submit now, collect later
+
+```python
+from movoa import submit, status, wait
+
+task_id = submit("a lighthouse in a storm, waves crashing", "minimax-h3", duration=6)
+print(status(task_id)["status"])  # pending | processing | success | failed | canceled
+url = wait(task_id)               # polls every 10 seconds, 30 minutes by default
+```
+
+While a run waits in line, `status()` returns `queued: True` and `queueEta` in seconds.
+
+## Errors worth catching
+
+Each failure is its own subclass of `MovoaError`, so you can branch on what to do next:
+
+- `AuthError`: no key, or the key is wrong or deleted; create one at [movoa.ai/settings/apikeys](https://movoa.ai/settings/apikeys)
+- `QuotaError`: the account does not have enough credits for this run
+- `PlanError`: that model or quality needs a plan on the account
+- `BusyError`: too many runs on this account are generating at once
+- `RejectedError`: the content filter refused the prompt, or a cooldown is active; reword it
+- `GenerationError`: the run was accepted but failed or was canceled; `.error_message` says why
+- `TimeoutError`: the wait ran out; `.task_id` lets you check the run later with `status()`
+
+Any other refusal raises `MovoaError` with the server's message.
+
+MIT licensed. Made by [Movoa](https://movoa.ai/?utm_source=pypi&utm_medium=package).

movoa-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "movoa"
+version = "0.1.0"
+description = "Unlimited AI video generator with sound: on paid plans the tenth take of a shot costs what the first did, and your first clip is free to make right now. Official Python SDK for Movoa (movoa.ai): text to video and photo to video with sound from your own code."
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [{ name = "Movoa (https://movoa.ai)" }]
+keywords = ["ai", "video-generation", "ai-video-generator", "text-to-video", "image-to-video", "photo-to-video", "ai-video-with-audio", "minimax-h3", "seedance-2-5", "veo-3", "movoa"]
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Topic :: Multimedia :: Video",
+]
+
+[project.urls]
+Homepage = "https://movoa.ai/?utm_source=pypi&utm_medium=package"
+"Text to video" = "https://movoa.ai/video/text-to-video"
+"API keys" = "https://movoa.ai/settings/apikeys"
+Pricing = "https://movoa.ai/pricing"
+Source = "https://github.com/hanshs474/movoa-py"
+
+[tool.setuptools.packages.find]
+where = ["src"]

movoa-0.1.0/setup.cfg

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

movoa-0.1.0/src/movoa/__init__.py

@@ -0,0 +1,305 @@
+"""Official Python SDK for Movoa (https://movoa.ai), the AI video generator with sound.
+
+    from movoa import generate_video
+    clip = generate_video("a paper boat drifting down a rain gutter, low angle")
+    still = generate_video("the camera slowly orbits the statue",
+                           image_url="https://example.com/statue.jpg")
+
+Create a key at https://movoa.ai/settings/apikeys and pass it as ``api_key=``
+or set ``MOVOA_API_KEY``. Runs cost credits on your Movoa account, at the
+prices on https://movoa.ai/pricing.
+
+Standard library only.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+import urllib.error
+import urllib.request
+from typing import Any, Callable, Dict, Optional, Tuple
+
+__version__ = "0.1.0"
+__all__ = [
+    "generate_video",
+    "submit",
+    "status",
+    "wait",
+    "credits",
+    "MovoaError",
+    "AuthError",
+    "QuotaError",
+    "PlanError",
+    "BusyError",
+    "RejectedError",
+    "GenerationError",
+    "TimeoutError",
+    "MODELS",
+    "DEFAULT_MODEL",
+    "BASE_URL",
+]
+
+BASE_URL = "https://movoa.ai"
+KEYS_URL = BASE_URL + "/settings/apikeys"
+
+#: Model ids. ``minimax-h3`` is the default and the cheapest.
+MODELS = (
+    "minimax-h3",
+    "veo-3-1-fast",
+    "seedance-2-5",
+    "seedance-2",
+    "seedance-2-fast",
+    "seedance-2-mini",
+)
+DEFAULT_MODEL = "minimax-h3"
+
+POLL_EVERY = 10.0
+TIMEOUT = 30 * 60.0
+
+
+class MovoaError(RuntimeError):
+    """Base class. Catch a subclass to decide what to do next.
+
+    ``status`` is the HTTP status, ``code`` the envelope code (0, -1, -2, -3),
+    ``reason`` the ``data.reason`` the service sent, if any.
+    """
+
+    def __init__(
+        self,
+        message: str,
+        status: Optional[int] = None,
+        code: Optional[int] = None,
+        reason: Optional[str] = None,
+        task_id: Optional[str] = None,
+    ):
+        super().__init__(message)
+        self.status = status
+        self.code = code
+        self.reason = reason
+        self.task_id = task_id
+
+
+class AuthError(MovoaError):
+    """No API key, or the key is invalid or deleted. Create one at /settings/apikeys."""
+
+
+class QuotaError(MovoaError):
+    """The account does not have enough credits for this run."""
+
+
+class PlanError(MovoaError):
+    """This model or quality needs a plan, or the account has never bought credits."""
+
+
+class BusyError(MovoaError):
+    """Too many runs on this account are generating at once. Wait for one to finish."""
+
+
+class RejectedError(MovoaError):
+    """The content filter refused the prompt (code -2) or a cooldown is active (code -3). Reword it."""
+
+
+class GenerationError(MovoaError):
+    """The run was accepted but ended as failed or canceled.
+
+    ``error_message`` and ``failure_kind`` carry what the service reported.
+    """
+
+    def __init__(self, message: str, task_id: str, error_message: Optional[str] = None, failure_kind: Optional[str] = None):
+        super().__init__(message, task_id=task_id)
+        self.error_message = error_message
+        self.failure_kind = failure_kind
+
+
+class TimeoutError(MovoaError):  # noqa: A001 - mirrors the SDK error set of every language
+    """The wait ran out. The run may still finish; ``task_id`` lets you check it later."""
+
+
+#: (method, url, body, headers) -> (http_status, raw_body_bytes). Raise OSError on network failure.
+Transport = Callable[[str, str, Optional[dict], dict], Tuple[int, bytes]]
+
+
+def _http(method: str, url: str, body: Optional[dict], headers: dict) -> Tuple[int, bytes]:
+    data = json.dumps(body).encode() if body is not None else b""
+    req = urllib.request.Request(url, data=data, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(req, timeout=60) as r:
+            return r.status, r.read()
+    except urllib.error.HTTPError as e:
+        return e.code, e.read() or b""
+
+
+def _base(base_url: Optional[str]) -> str:
+    return (base_url or os.environ.get("MOVOA_BASE_URL") or BASE_URL).rstrip("/")
+
+
+def _key(api_key: Optional[str]) -> str:
+    key = (api_key or os.environ.get("MOVOA_API_KEY") or "").strip()
+    if not key:
+        raise AuthError(f"No API key: pass api_key= or set MOVOA_API_KEY. Create a key at {KEYS_URL}")
+    return key
+
+
+def _raise_for(status_code: int, env: dict) -> None:
+    """Map a refusal to the subclass that says what to do next.
+
+    movoa.ai answers almost every refusal as HTTP 200 with a non-zero ``code``
+    and a ``data.reason``, so the status code alone reads a refusal as success.
+    """
+    code = env.get("code") if isinstance(env.get("code"), int) else None
+    data = env.get("data") if isinstance(env.get("data"), dict) else {}
+    reason = data.get("reason") if isinstance(data.get("reason"), str) else None
+    msg = str(env.get("message") or f"request failed (HTTP {status_code})")
+    kw = dict(status=status_code, code=code, reason=reason)
+    if status_code == 401:
+        raise AuthError(f"{msg} (create a key at {KEYS_URL})" if KEYS_URL not in msg else msg, **kw)
+    if code in (-2, -3):
+        raise RejectedError(msg, **kw)
+    if reason == "insufficient_credits":
+        raise QuotaError(msg, **kw)
+    if reason == "plan_required":
+        raise PlanError(msg, **kw)
+    if reason == "concurrency":
+        raise BusyError(msg, **kw)
+    if "no auth" in msg.lower():
+        raise AuthError(f"{msg}. Create a key at {KEYS_URL}", **kw)
+    raise MovoaError(msg, **kw)
+
+
+def _call(path: str, body: Optional[dict], api_key: Optional[str], base_url: Optional[str], transport: Optional[Transport]) -> dict:
+    headers = {
+        "Authorization": f"Bearer {_key(api_key)}",
+        "Content-Type": "application/json",
+        "User-Agent": f"movoa-python/{__version__}",
+    }
+    st, raw = (transport or _http)("POST", _base(base_url) + path, body, headers)
+    try:
+        env = json.loads(raw) if raw else {}
+    except ValueError:
+        env = None
+    if st == 401:
+        _raise_for(401, env if isinstance(env, dict) else {})
+    if not isinstance(env, dict):
+        raise MovoaError(f"movoa.ai returned a non-JSON response (HTTP {st})", status=st)
+    if st < 400 and env.get("code") == 0:
+        return env
+    _raise_for(st, env)
+    raise AssertionError("unreachable")
+
+
+def submit(
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    image_url: Optional[str] = None,
+    *,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    transport: Optional[Transport] = None,
+    **options: Any,
+) -> str:
+    """Start one run and return its task id without waiting.
+
+    ``image_url`` (a public https image) makes it image-to-video, with the
+    photo as the first frame. Extra keyword arguments go into ``options`` as
+    they are, e.g. ``duration=6, resolution="768p", aspect_ratio="9:16"``.
+    """
+    if not str(prompt or "").strip():
+        raise ValueError("prompt is required")
+    opts: Dict[str, Any] = {"sound": True}
+    opts.update({k: v for k, v in options.items() if v is not None})
+    if image_url:
+        opts["image_input"] = [image_url]
+    body = {
+        # The server routes by model; this only has to be non-empty.
+        "provider": "auto",
+        "mediaType": "video",
+        "model": model,
+        "scene": "image-to-video" if image_url else "text-to-video",
+        "prompt": prompt,
+        "options": opts,
+    }
+    env = _call("/api/ai/generate", body, api_key, base_url, transport)
+    task_id = (env.get("data") or {}).get("id")
+    if not task_id:
+        raise MovoaError("movoa.ai accepted the run but returned no id")
+    return str(task_id)
+
+
+def status(
+    task_id: str,
+    *,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    transport: Optional[Transport] = None,
+) -> Dict[str, Any]:
+    """Return the run record. ``status`` is pending, processing, success, failed
+    or canceled; ``videos`` holds the result URLs on success; ``queued`` and
+    ``queueEta`` (seconds) are set while it waits in line."""
+    env = _call("/api/ai/query", {"taskId": task_id}, api_key, base_url, transport)
+    data = env.get("data")
+    return data if isinstance(data, dict) else {}
+
+
+def wait(
+    task_id: str,
+    *,
+    api_key: Optional[str] = None,
+    timeout: float = TIMEOUT,
+    poll_every: float = POLL_EVERY,
+    base_url: Optional[str] = None,
+    transport: Optional[Transport] = None,
+) -> str:
+    """Poll a run every ``poll_every`` seconds until it finishes and return the video URL."""
+    deadline = time.monotonic() + timeout
+    while True:
+        try:
+            data = status(task_id, api_key=api_key, base_url=base_url, transport=transport)
+        except OSError:
+            data = {}  # a dropped poll is not a failed generation
+        state = str(data.get("status") or "").lower()
+        if state == "success":
+            videos = data.get("videos") or []
+            if not videos:
+                raise GenerationError(f"run {task_id} finished with no video", task_id)
+            return str(videos[0])
+        if state in ("failed", "canceled"):
+            em = data.get("errorMessage")
+            raise GenerationError(
+                f"run {task_id} {state}" + (f": {em}" if em else ""), task_id, em, data.get("failureKind")
+            )
+        if time.monotonic() + poll_every > deadline:
+            raise TimeoutError(
+                f"run {task_id} is still generating after {timeout:g}s; check it later with status()",
+                task_id=task_id,
+            )
+        time.sleep(poll_every)
+
+
+def generate_video(
+    prompt: str,
+    model: str = DEFAULT_MODEL,
+    image_url: Optional[str] = None,
+    *,
+    api_key: Optional[str] = None,
+    timeout: float = TIMEOUT,
+    poll_every: float = POLL_EVERY,
+    base_url: Optional[str] = None,
+    transport: Optional[Transport] = None,
+    **options: Any,
+) -> str:
+    """Generate one clip with sound and return its URL."""
+    task_id = submit(prompt, model, image_url, api_key=api_key, base_url=base_url, transport=transport, **options)
+    return wait(task_id, api_key=api_key, timeout=timeout, poll_every=poll_every, base_url=base_url, transport=transport)
+
+
+def credits(
+    *,
+    api_key: Optional[str] = None,
+    base_url: Optional[str] = None,
+    transport: Optional[Transport] = None,
+) -> int:
+    """Return the remaining credits on the account."""
+    env = _call("/api/user/get-user-credits", None, api_key, base_url, transport)
+    return int((env.get("data") or {}).get("remainingCredits") or 0)

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

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: movoa
+Version: 0.1.0
+Summary: Unlimited AI video generator with sound: on paid plans the tenth take of a shot costs what the first did, and your first clip is free to make right now. Official Python SDK for Movoa (movoa.ai): text to video and photo to video with sound from your own code.
+Author: Movoa (https://movoa.ai)
+License: MIT
+Project-URL: Homepage, https://movoa.ai/?utm_source=pypi&utm_medium=package
+Project-URL: Text to video, https://movoa.ai/video/text-to-video
+Project-URL: API keys, https://movoa.ai/settings/apikeys
+Project-URL: Pricing, https://movoa.ai/pricing
+Project-URL: Source, https://github.com/hanshs474/movoa-py
+Keywords: ai,video-generation,ai-video-generator,text-to-video,image-to-video,photo-to-video,ai-video-with-audio,minimax-h3,seedance-2-5,veo-3,movoa
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# movoa
+
+Unlimited AI video generator with sound: on paid plans the tenth take of a shot costs what the first did, and your first clip is free to make right now. This is the official Python SDK for [Movoa](https://movoa.ai/?utm_source=pypi&utm_medium=package): one API key turns a prompt into [text to video](https://movoa.ai/video/text-to-video), or a still into [photo to video](https://movoa.ai/video/photo-to-video), and every clip comes back as [AI video with audio](https://movoa.ai/video/ai-video-with-audio).
+
+```bash
+pip install movoa
+```
+
+```python
+from movoa import generate_video
+
+clip = generate_video("a paper boat drifting down a rain gutter, low angle, slow push-in")
+print(clip)  # URL of the finished MP4, sound included
+```
+
+Standard library only, no dependencies. `generate_video` submits the run, waits for it and returns the URL of the finished file.
+
+## API key
+
+Sign in on [movoa.ai](https://movoa.ai/?utm_source=pypi&utm_medium=package), create a key at [movoa.ai/settings/apikeys](https://movoa.ai/settings/apikeys), then pass it as `api_key=` or export it:
+
+```bash
+export MOVOA_API_KEY=sk-...
+```
+
+Runs cost credits on your Movoa account, at the prices on [movoa.ai/pricing](https://movoa.ai/pricing).
+
+```python
+from movoa import credits
+print(credits())  # remaining credits on the account
+```
+
+## Text to video and photo to video
+
+```python
+from movoa import generate_video
+
+# text to video, vertical, 10 seconds
+generate_video("a fox trotting through fresh snow at dawn, tracking shot",
+               duration=10, aspect_ratio="9:16")
+
+# photo to video: the photo becomes the first frame
+generate_video("the camera slowly orbits the statue", image_url="https://example.com/statue.jpg")
+
+# another model
+generate_video("a street drummer in the rain, close-up", model="seedance-2-5", duration=10, resolution="720p")
+```
+
+| model | options |
+|---|---|
+| `minimax-h3` (default) | `duration` 4 / 5 / 6 / 8 / 10 / 15 · `resolution` 480p / 768p · `aspect_ratio` 16:9 / 9:16 / 1:1 |
+| `veo-3-1-fast` | `duration` 8 · `resolution` 720p · `aspect_ratio` 16:9 / 9:16 (photo to video: 16:9) |
+| `seedance-2-5` | `duration` 5 / 10 / 15 / 20 / 25 / 30 · `resolution` 480p / 720p · `aspect_ratio` 16:9 / 9:16 / 1:1 |
+| `seedance-2`, `seedance-2-fast`, `seedance-2-mini` | `duration` 4 / 6 / 8 / 10 · `resolution` 480p / 720p · `aspect_ratio` |
+
+Any extra keyword argument is sent in `options` as it is. Every run asks for sound. On the site: [Seedance 2.5](https://movoa.ai/video/seedance-2-5) and [Veo 3](https://movoa.ai/video/google-veo-3).
+
+## Submit now, collect later
+
+```python
+from movoa import submit, status, wait
+
+task_id = submit("a lighthouse in a storm, waves crashing", "minimax-h3", duration=6)
+print(status(task_id)["status"])  # pending | processing | success | failed | canceled
+url = wait(task_id)               # polls every 10 seconds, 30 minutes by default
+```
+
+While a run waits in line, `status()` returns `queued: True` and `queueEta` in seconds.
+
+## Errors worth catching
+
+Each failure is its own subclass of `MovoaError`, so you can branch on what to do next:
+
+- `AuthError`: no key, or the key is wrong or deleted; create one at [movoa.ai/settings/apikeys](https://movoa.ai/settings/apikeys)
+- `QuotaError`: the account does not have enough credits for this run
+- `PlanError`: that model or quality needs a plan on the account
+- `BusyError`: too many runs on this account are generating at once
+- `RejectedError`: the content filter refused the prompt, or a cooldown is active; reword it
+- `GenerationError`: the run was accepted but failed or was canceled; `.error_message` says why
+- `TimeoutError`: the wait ran out; `.task_id` lets you check the run later with `status()`
+
+Any other refusal raises `MovoaError` with the server's message.
+
+MIT licensed. Made by [Movoa](https://movoa.ai/?utm_source=pypi&utm_medium=package).

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

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/movoa/__init__.py
+src/movoa.egg-info/PKG-INFO
+src/movoa.egg-info/SOURCES.txt
+src/movoa.egg-info/dependency_links.txt
+src/movoa.egg-info/top_level.txt
+tests/test_movoa.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1 @@
+movoa

movoa-0.1.0/tests/test_movoa.py

@@ -0,0 +1,135 @@
+import json
+import os
+import unittest
+
+import movoa
+
+
+def reply(status, body):
+    raw = body if isinstance(body, bytes) else json.dumps(body).encode()
+    return status, raw
+
+
+def fake(calls, polls, submit_reply=None):
+    """Answers in the real response shapes of movoa.ai."""
+    polls = list(polls)
+    submit_reply = submit_reply or reply(200, {"code": 0, "message": "ok", "data": {"id": "t1", "status": "pending"}})
+
+    def t(method, url, body, headers):
+        calls.append((method, url, body, headers))
+        if url.endswith("/api/ai/generate"):
+            return submit_reply
+        if url.endswith("/api/ai/query"):
+            return reply(200, {"code": 0, "message": "ok", "data": polls.pop(0)})
+        return reply(200, {"code": 0, "message": "ok", "data": {"remainingCredits": 42}})
+
+    return t
+
+
+class MovoaTests(unittest.TestCase):
+    def setUp(self):
+        self.live_key = os.environ.pop("MOVOA_API_KEY", None)
+        os.environ.pop("MOVOA_BASE_URL", None)
+
+    def test_text_to_video_success(self):
+        calls = []
+        polls = [
+            {"id": "t1", "status": "pending", "queued": True, "queueEta": 30},
+            {"id": "t1", "status": "processing"},
+            {"id": "t1", "status": "success", "videos": ["https://cdn/v.mp4"]},
+        ]
+        url = movoa.generate_video("a boat", api_key="sk-abc", duration=6, poll_every=0, base_url="https://t", transport=fake(calls, polls))
+        self.assertEqual(url, "https://cdn/v.mp4")
+        method, u, body, headers = calls[0]
+        self.assertEqual((method, u), ("POST", "https://t/api/ai/generate"))
+        self.assertEqual(headers["Authorization"], "Bearer sk-abc")
+        self.assertEqual(body, {
+            "provider": "auto", "mediaType": "video", "model": "minimax-h3", "scene": "text-to-video",
+            "prompt": "a boat", "options": {"sound": True, "duration": 6},
+        })
+        self.assertEqual(calls[1][2], {"taskId": "t1"})
+        self.assertEqual(len(calls), 4)
+
+    def test_image_to_video_body(self):
+        calls = []
+        movoa.submit("orbit", "seedance-2-5", image_url="https://x/y.jpg", api_key="sk", aspect_ratio="9:16", transport=fake(calls, []))
+        body = calls[0][2]
+        self.assertEqual(body["scene"], "image-to-video")
+        self.assertEqual(body["model"], "seedance-2-5")
+        self.assertEqual(body["options"], {"sound": True, "aspect_ratio": "9:16", "image_input": ["https://x/y.jpg"]})
+
+    def test_base_url_from_env(self):
+        os.environ["MOVOA_BASE_URL"] = "http://localhost:3000/"
+        calls = []
+        movoa.credits(api_key="sk", transport=fake(calls, []))
+        self.assertEqual(calls[0][1], "http://localhost:3000/api/user/get-user-credits")
+
+    def test_validates_prompt(self):
+        with self.assertRaises(ValueError):
+            movoa.submit("  ", api_key="sk")
+
+    def test_needs_a_key(self):
+        def boom(*a):
+            raise AssertionError("no request without a key")
+
+        with self.assertRaises(movoa.AuthError):
+            movoa.credits(transport=boom)
+
+    def test_error_mapping(self):
+        cases = [
+            (reply(401, {"code": -1, "message": "Invalid API key. Create one at https://movoa.ai/settings/apikeys", "data": {"reason": "invalid_api_key"}}), movoa.AuthError),
+            (reply(401, b"<html>unauthorized</html>"), movoa.AuthError),
+            (reply(200, {"code": -1, "message": "insufficient credits", "data": {"reason": "insufficient_credits"}}), movoa.QuotaError),
+            (reply(200, {"code": -1, "message": "This model or quality needs a plan.", "data": {"reason": "plan_required"}}), movoa.PlanError),
+            (reply(200, {"code": -1, "message": "busy", "data": {"reason": "concurrency"}}), movoa.BusyError),
+            (reply(200, {"code": -2, "message": "blocked"}), movoa.RejectedError),
+            (reply(200, {"code": -3, "message": "cooldown"}), movoa.RejectedError),
+            (reply(200, {"code": -1, "message": "no auth, please sign in"}), movoa.AuthError),
+        ]
+        for r, exc in cases:
+            with self.assertRaises(exc, msg=str(r)):
+                movoa.submit("x", api_key="sk", transport=fake([], [], r))
+        for r in (reply(200, {"code": -1, "message": "generation failed, please try again"}), reply(502, b"Bad gateway"), reply(500, {"code": -1, "message": "oops"})):
+            with self.assertRaises(movoa.MovoaError) as cm:
+                movoa.submit("x", api_key="sk", transport=fake([], [], r))
+            self.assertIs(type(cm.exception), movoa.MovoaError)
+        with self.assertRaises(movoa.MovoaError) as cm:
+            movoa.submit("x", api_key="sk", transport=fake([], [], reply(200, {"code": -1, "message": "generation failed, please try again"})))
+        self.assertIn("generation failed", str(cm.exception))
+
+    def test_failed_and_canceled(self):
+        with self.assertRaises(movoa.GenerationError) as cm:
+            movoa.generate_video("x", api_key="sk", poll_every=0, transport=fake([], [{"id": "t1", "status": "failed", "errorMessage": "provider down", "failureKind": "upstream"}]))
+        self.assertEqual(cm.exception.error_message, "provider down")
+        self.assertEqual(cm.exception.failure_kind, "upstream")
+        self.assertEqual(cm.exception.task_id, "t1")
+        self.assertIn("provider down", str(cm.exception))
+        with self.assertRaises(movoa.GenerationError):
+            movoa.wait("t1", api_key="sk", poll_every=0, transport=fake([], [{"id": "t1", "status": "canceled"}]))
+
+    def test_timeout_carries_task_id(self):
+        polls = [{"id": "t1", "status": "processing", "queued": True, "queueEta": 60}] * 5
+        with self.assertRaises(movoa.TimeoutError) as cm:
+            movoa.wait("t1", api_key="sk", timeout=0.001, poll_every=0.01, transport=fake([], polls))
+        self.assertEqual(cm.exception.task_id, "t1")
+
+    def test_status_and_credits(self):
+        st = movoa.status("t1", api_key="sk", transport=fake([], [{"id": "t1", "status": "success", "videos": ["https://cdn/v.mp4"]}]))
+        self.assertEqual(st["videos"][0], "https://cdn/v.mp4")
+        self.assertEqual(movoa.credits(api_key="sk", transport=fake([], [])), 42)
+
+        def no_auth(method, url, body, headers):
+            return reply(200, {"code": -1, "message": "no auth, please sign in"})
+
+        with self.assertRaises(movoa.AuthError):
+            movoa.credits(api_key="sk", transport=no_auth)
+
+    @unittest.skipUnless(os.environ.get("MOVOA_LIVE"), "set MOVOA_LIVE=1 MOVOA_API_KEY=sk-... after key auth is live")
+    def test_live_smoke(self):
+        self.assertGreaterEqual(movoa.credits(api_key=self.live_key), 0)
+        with self.assertRaises(movoa.AuthError):
+            movoa.submit("test", api_key="sk-wrong-key-for-test")
+
+
+if __name__ == "__main__":
+    unittest.main()