spudzy-vid 0.1.0__tar.gz

spudzy_vid-0.1.0/LICENSE

@@ -0,0 +1,7 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software to deal in the Software without restriction.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND.

spudzy_vid-0.1.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: spudzy-vid
+Version: 0.1.0
+Summary: Python wrapper for the browser-only Spudzy Vid procedural prompt-to-video generator.
+Author: Spudzy Vid Package Author
+License: MIT
+Project-URL: Homepage, https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js
+Keywords: video,canvas,mediarecorder,prompt-to-video,playwright
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.45
+Dynamic: license-file
+
+# spudzy-vid
+
+Python wrapper for **Spudzy Vid / RealLifeVideo**.
+
+It loads this browser-only JavaScript file:
+
+`https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js`
+
+Because the JavaScript uses browser APIs like `Canvas`, `canvas.captureStream`, and `MediaRecorder`, the wrapper runs it inside Chromium with Playwright, then returns the video data to Python and can save a `.webm` file.
+
+## Install locally
+
+```bash
+python -m pip install -e .
+python -m playwright install chromium
+```
+
+## Python usage
+
+```python
+from spudzy_vid import generate
+
+result = generate(
+    "make a dragon fly in the rain in an rpg game with the effect fire",
+    output="dragon.webm",
+    seconds=6,
+    width=960,
+    height=540,
+    fps=30,
+)
+print(result["ok"], result["correctedPrompt"], result["output"])
+```
+
+## CLI usage
+
+```bash
+spudzy-vid "recreate this futuristic UI being used in a video" -o ui.webm --seconds 6
+```
+
+## Build and publish
+
+```bash
+python -m pip install -U build twine
+python -m build
+python -m twine upload dist/*
+```

spudzy_vid-0.1.0/README.md

@@ -0,0 +1,46 @@
+# spudzy-vid
+
+Python wrapper for **Spudzy Vid / RealLifeVideo**.
+
+It loads this browser-only JavaScript file:
+
+`https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js`
+
+Because the JavaScript uses browser APIs like `Canvas`, `canvas.captureStream`, and `MediaRecorder`, the wrapper runs it inside Chromium with Playwright, then returns the video data to Python and can save a `.webm` file.
+
+## Install locally
+
+```bash
+python -m pip install -e .
+python -m playwright install chromium
+```
+
+## Python usage
+
+```python
+from spudzy_vid import generate
+
+result = generate(
+    "make a dragon fly in the rain in an rpg game with the effect fire",
+    output="dragon.webm",
+    seconds=6,
+    width=960,
+    height=540,
+    fps=30,
+)
+print(result["ok"], result["correctedPrompt"], result["output"])
+```
+
+## CLI usage
+
+```bash
+spudzy-vid "recreate this futuristic UI being used in a video" -o ui.webm --seconds 6
+```
+
+## Build and publish
+
+```bash
+python -m pip install -U build twine
+python -m build
+python -m twine upload dist/*
+```

spudzy_vid-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "spudzy-vid"
+version = "0.1.0"
+description = "Python wrapper for the browser-only Spudzy Vid procedural prompt-to-video generator."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "Spudzy Vid Package Author" }]
+dependencies = ["playwright>=1.45"]
+keywords = ["video", "canvas", "mediarecorder", "prompt-to-video", "playwright"]
+
+[project.urls]
+Homepage = "https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js"
+
+[project.scripts]
+spudzy-vid = "spudzy_vid.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

spudzy_vid-0.1.0/setup.cfg

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

spudzy_vid-0.1.0/src/spudzy_vid/__init__.py

@@ -0,0 +1,3 @@
+from .runner import JS_URL, SpudzyVidError, generate, generate_async, parse_prompt, parse_prompt_async, correct_prompt, correct_prompt_async
+
+__all__ = ["JS_URL", "SpudzyVidError", "generate", "generate_async", "parse_prompt", "parse_prompt_async", "correct_prompt", "correct_prompt_async"]

spudzy_vid-0.1.0/src/spudzy_vid/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

spudzy_vid-0.1.0/src/spudzy_vid/cli.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from .runner import SpudzyVidError, generate
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(description="Generate Spudzy Vid videos from Python.")
+    parser.add_argument("prompt")
+    parser.add_argument("-o", "--output", default="spudzy_vid_output.webm")
+    parser.add_argument("--width", type=int, default=960)
+    parser.add_argument("--height", type=int, default=540)
+    parser.add_argument("--fps", type=int, default=30)
+    parser.add_argument("--seconds", type=float, default=6)
+    parser.add_argument("--bitrate", type=int, default=6000000)
+    parser.add_argument("--seed", type=int, default=None)
+    parser.add_argument("--return-frames", action="store_true")
+    parser.add_argument("--show-browser", action="store_true")
+    parser.add_argument("--json", action="store_true")
+    args = parser.parse_args(argv)
+    try:
+        result = generate(args.prompt, output=args.output, width=args.width, height=args.height, fps=args.fps, seconds=args.seconds, bitrate=args.bitrate, seed=args.seed, returnFrames=args.return_frames, headless=not args.show_browser)
+    except SpudzyVidError as exc:
+        print(f"spudzy-vid error: {exc}", file=sys.stderr)
+        return 1
+    if args.json:
+        printable = dict(result)
+        if printable.get("videoBase64"):
+            printable["videoBase64"] = f"<base64 omitted: {len(result['videoBase64'])} chars>"
+        print(json.dumps(printable, indent=2))
+    else:
+        print(f"ok: {result.get('ok')}")
+        print(f"corrected prompt: {result.get('correctedPrompt')}")
+        print(f"mime type: {result.get('mimeType')}")
+        print(f"saved: {result.get('output')}")
+        if result.get("reason"):
+            print(f"reason: {result.get('reason')}")
+    return 0
+
+if __name__ == "__main__":
+    raise SystemExit(main())

spudzy_vid-0.1.0/src/spudzy_vid/runner.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+
+import asyncio
+import base64
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+JS_URL = "https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js"
+
+class SpudzyVidError(RuntimeError):
+    pass
+
+def _clean_options(options: Dict[str, Any]) -> Dict[str, Any]:
+    blocked = {"output", "headless", "timeout", "js_url"}
+    clean: Dict[str, Any] = {}
+    for key, value in options.items():
+        if key in blocked or value is None:
+            continue
+        try:
+            json.dumps(value)
+        except TypeError:
+            continue
+        clean[key] = value
+    return clean
+
+async def _run_js_function(function_name: str, prompt: str, options: Dict[str, Any]) -> Any:
+    try:
+        from playwright.async_api import async_playwright
+    except Exception as exc:
+        raise SpudzyVidError("Playwright is required. Run: python -m pip install playwright; then: python -m playwright install chromium") from exc
+
+    headless = bool(options.pop("headless", True))
+    timeout = int(options.pop("timeout", 120_000))
+    js_url = str(options.pop("js_url", JS_URL))
+    browser_options = _clean_options(options)
+    html = "<!doctype html><html><head><meta charset='utf-8'></head><body></body></html>"
+
+    async with async_playwright() as pw:
+        browser = await pw.chromium.launch(headless=headless)
+        page = await browser.new_page()
+        page.set_default_timeout(timeout)
+        try:
+            await page.set_content(html, wait_until="domcontentloaded")
+            await page.add_script_tag(url=js_url)
+            await page.wait_for_function("() => !!window.RealLifeVideo", timeout=timeout)
+
+            if function_name == "generate":
+                return await page.evaluate("""
+                    async ({ prompt, options }) => {
+                      const data = await window.RealLifeVideo.generate(prompt, options);
+                      let videoBase64 = null;
+                      let videoSize = 0;
+                      if (data.blob) {
+                        const arrayBuffer = await data.blob.arrayBuffer();
+                        const bytes = new Uint8Array(arrayBuffer);
+                        let binary = "";
+                        const chunk = 0x8000;
+                        for (let i = 0; i < bytes.length; i += chunk) {
+                          binary += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk));
+                        }
+                        videoBase64 = btoa(binary);
+                        videoSize = data.blob.size || bytes.length;
+                      }
+                      return {
+                        ok: data.ok,
+                        reason: data.reason || null,
+                        originalPrompt: data.originalPrompt,
+                        correctedPrompt: data.correctedPrompt,
+                        parsed: data.parsed,
+                        width: data.width,
+                        height: data.height,
+                        fps: data.fps,
+                        seconds: data.seconds,
+                        frameCount: data.frameCount,
+                        mimeType: data.mimeType,
+                        videoBase64,
+                        videoSize,
+                        framePreviewCount: data.frames ? data.frames.length : 0,
+                        frames: data.frames || []
+                      };
+                    }
+                """, {"prompt": prompt, "options": browser_options})
+
+            if function_name == "parsePrompt":
+                return await page.evaluate("({ prompt, options }) => window.RealLifeVideo.parsePrompt(prompt, options)", {"prompt": prompt, "options": browser_options})
+            if function_name == "correctPrompt":
+                return await page.evaluate("({ prompt, options }) => window.RealLifeVideo.correctPrompt(prompt, options)", {"prompt": prompt, "options": browser_options})
+            raise SpudzyVidError(f"Unknown JS function: {function_name}")
+        finally:
+            await browser.close()
+
+async def generate_async(prompt: str, output: Optional[str | Path] = None, **options: Any) -> Dict[str, Any]:
+    result = await _run_js_function("generate", prompt, dict(options))
+    if output and result.get("videoBase64"):
+        out = Path(output)
+        out.parent.mkdir(parents=True, exist_ok=True)
+        out.write_bytes(base64.b64decode(result["videoBase64"]))
+        result["output"] = str(out)
+    return result
+
+def generate(prompt: str, output: Optional[str | Path] = None, **options: Any) -> Dict[str, Any]:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(generate_async(prompt, output=output, **options))
+    raise SpudzyVidError("generate() cannot run inside an active event loop. Use await generate_async(...).")
+
+async def parse_prompt_async(prompt: str, **options: Any) -> Dict[str, Any]:
+    return await _run_js_function("parsePrompt", prompt, dict(options))
+
+def parse_prompt(prompt: str, **options: Any) -> Dict[str, Any]:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(parse_prompt_async(prompt, **options))
+    raise SpudzyVidError("parse_prompt() cannot run inside an active event loop. Use await parse_prompt_async(...).")
+
+async def correct_prompt_async(prompt: str, **options: Any) -> str:
+    return await _run_js_function("correctPrompt", prompt, dict(options))
+
+def correct_prompt(prompt: str, **options: Any) -> str:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(correct_prompt_async(prompt, **options))
+    raise SpudzyVidError("correct_prompt() cannot run inside an active event loop. Use await correct_prompt_async(...).")

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

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: spudzy-vid
+Version: 0.1.0
+Summary: Python wrapper for the browser-only Spudzy Vid procedural prompt-to-video generator.
+Author: Spudzy Vid Package Author
+License: MIT
+Project-URL: Homepage, https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js
+Keywords: video,canvas,mediarecorder,prompt-to-video,playwright
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: playwright>=1.45
+Dynamic: license-file
+
+# spudzy-vid
+
+Python wrapper for **Spudzy Vid / RealLifeVideo**.
+
+It loads this browser-only JavaScript file:
+
+`https://alaricholt677.github.io/PKGS/spudzy-vid/spudzy-vid-js.js`
+
+Because the JavaScript uses browser APIs like `Canvas`, `canvas.captureStream`, and `MediaRecorder`, the wrapper runs it inside Chromium with Playwright, then returns the video data to Python and can save a `.webm` file.
+
+## Install locally
+
+```bash
+python -m pip install -e .
+python -m playwright install chromium
+```
+
+## Python usage
+
+```python
+from spudzy_vid import generate
+
+result = generate(
+    "make a dragon fly in the rain in an rpg game with the effect fire",
+    output="dragon.webm",
+    seconds=6,
+    width=960,
+    height=540,
+    fps=30,
+)
+print(result["ok"], result["correctedPrompt"], result["output"])
+```
+
+## CLI usage
+
+```bash
+spudzy-vid "recreate this futuristic UI being used in a video" -o ui.webm --seconds 6
+```
+
+## Build and publish
+
+```bash
+python -m pip install -U build twine
+python -m build
+python -m twine upload dist/*
+```

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

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+pyproject.toml
+src/spudzy_vid/__init__.py
+src/spudzy_vid/__main__.py
+src/spudzy_vid/cli.py
+src/spudzy_vid/runner.py
+src/spudzy_vid.egg-info/PKG-INFO
+src/spudzy_vid.egg-info/SOURCES.txt
+src/spudzy_vid.egg-info/dependency_links.txt
+src/spudzy_vid.egg-info/entry_points.txt
+src/spudzy_vid.egg-info/requires.txt
+src/spudzy_vid.egg-info/top_level.txt

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

@@ -0,0 +1 @@
+

spudzy_vid-0.1.0/src/spudzy_vid.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+spudzy-vid = spudzy_vid.cli:main

spudzy_vid-0.1.0/src/spudzy_vid.egg-info/requires.txt

@@ -0,0 +1 @@
+playwright>=1.45

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

@@ -0,0 +1 @@
+spudzy_vid