rushdaw 0.1.0__py3-none-any.whl

rushdaw/__init__.py

@@ -0,0 +1,3 @@
+"""RushDAW - a web based digital audio workstation served by Python."""
+
+__version__ = "0.1.0"

rushdaw/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

rushdaw/cli.py

@@ -0,0 +1,92 @@
+"""Command line entry point: ``rushdaw`` / ``python -m rushdaw``."""
+import argparse
+import errno
+import json
+import os
+import sys
+import urllib.request
+import threading
+import webbrowser
+
+from . import __version__
+from .server import make_server
+
+DEFAULT_PORT = 8765
+PORT_TRIES = 20  # when the default port is busy, try 8766, 8767, ...
+
+
+def _url(host, port):
+    return f"http://{'localhost' if host in ('127.0.0.1', '0.0.0.0') else host}:{port}/"
+
+
+def _running_rushdaw(host, port):
+    """Return /api/info of a RushDAW server already listening on host:port, else None."""
+    h = "127.0.0.1" if host in ("0.0.0.0", "") else host
+    try:
+        with urllib.request.urlopen(f"http://{h}:{port}/api/info", timeout=1.5) as r:
+            if not r.headers.get("Server", "").startswith("RushDAW/"):
+                return None
+            return json.loads(r.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def _bind(args):
+    """Create the server. If the port is busy: reuse an already running RushDAW (same settings),
+    otherwise (default port only) move on to the next free port. Returns (httpd, None) or (None, url_of_running)."""
+    port = args.port or DEFAULT_PORT
+    ports = [port] if args.port else range(port, port + PORT_TRIES)
+    for pt in ports:
+        try:
+            return make_server(args.host, pt, args.home, args.api_key), None
+        except OSError as e:
+            if e.errno != errno.EADDRINUSE:
+                raise
+        info = _running_rushdaw(args.host, pt)
+        if info is not None and not args.home and not args.api_key:
+            return None, _url(args.host, pt)  # RushDAW is already running there: just use it
+        why = "another RushDAW with different settings" if info is not None else "another program"
+        if args.port:
+            sys.exit(f"rushdaw: port {pt} is already in use by {why}. Start with a different --port, e.g. --port {pt + 1}.")
+        print(f"Port {pt} is in use by {why}, trying {pt + 1}…", flush=True)
+    sys.exit(f"rushdaw: no free port between {port} and {port + PORT_TRIES - 1}. Use --port.")
+
+
+def main(argv=None):
+    p = argparse.ArgumentParser(prog="rushdaw", description="RushDAW web based DAW")
+    p.add_argument("--host", default="127.0.0.1", help="bind address (default 127.0.0.1)")
+    p.add_argument("--port", type=int, default=None,
+                   help=f"port (default {DEFAULT_PORT}; if busy, the next free port is used automatically)")
+    p.add_argument("--no-browser", action="store_true", help="do not open a browser automatically")
+    p.add_argument("--home", default=None, help="data folder (default ~/.rushdaw or $RUSHDAW_HOME)")
+    p.add_argument("--api-key", default=os.environ.get("RUSHDAW_API_KEY"),
+                   help="optional: enable the MCP server (HTTP+SSE at /sse) protected by "
+                        "'Authorization: Bearer <KEY>' (default: $RUSHDAW_API_KEY; MCP is off when not set)")
+    p.add_argument("--version", action="version", version=f"rushdaw {__version__}")
+    args = p.parse_args(argv)
+
+    httpd, running = _bind(args)
+    if running:
+        print(f"RushDAW is already running at {running} – opening it.", flush=True)
+        if not args.no_browser:
+            webbrowser.open(running)
+        return
+    url = _url(args.host, httpd.server_address[1])
+    print(f"RushDAW {__version__} running at {url}  (Ctrl+C to stop)", flush=True)
+    print(f"Data: {httpd.RequestHandlerClass.storage.home}  (db.sql + file/)", flush=True)
+    if args.api_key:
+        print(f"MCP:  {url}sse  (HTTP+SSE transport, header 'Authorization: Bearer <api key>')", flush=True)
+    else:
+        print("MCP:  off (optional – start with --api-key KEY to enable)", flush=True)
+    if not args.no_browser:
+        threading.Timer(0.8, lambda: webbrowser.open(url)).start()
+    try:
+        httpd.serve_forever()
+    except KeyboardInterrupt:
+        print("\nStopping RushDAW.")
+    finally:
+        httpd.server_close()
+
+
+if __name__ == "__main__":
+    main()

rushdaw/export.py

@@ -0,0 +1,73 @@
+"""Convert a rendered WAV mixdown to other formats with ffmpeg."""
+import os
+import shutil
+import subprocess
+import tempfile
+
+# format -> (extension, mime, ffmpeg output args)
+FORMATS = {
+    "wav": ("wav", "audio/wav", None),
+    "mp3": ("mp3", "audio/mpeg", ["-codec:a", "libmp3lame", "-b:a", "320k"]),
+    "ogg": ("ogg", "audio/ogg", ["-codec:a", "libvorbis", "-q:a", "6"]),
+    "flac": ("flac", "audio/flac", ["-codec:a", "flac"]),
+    "m4a": ("m4a", "audio/mp4", ["-codec:a", "aac", "-b:a", "256k"]),
+    "aac": ("aac", "audio/aac", ["-codec:a", "aac", "-b:a", "256k"]),
+    "opus": ("opus", "audio/ogg", ["-codec:a", "libopus", "-b:a", "192k"]),
+    "mp4": ("mp4", "video/mp4", "VIDEO"),
+}
+
+
+def find_ffmpeg():
+    """Return path to an ffmpeg binary (system one first, then imageio-ffmpeg)."""
+    exe = shutil.which("ffmpeg")
+    if exe:
+        return exe
+    try:
+        import imageio_ffmpeg
+
+        return imageio_ffmpeg.get_ffmpeg_exe()
+    except Exception:
+        return None
+
+
+def available_formats():
+    if find_ffmpeg():
+        return list(FORMATS)
+    return ["wav"]
+
+
+def convert(wav_bytes, fmt, title="RushDAW"):
+    """Convert WAV bytes into ``fmt``. Returns (bytes, ext, mime)."""
+    fmt = fmt.lower()
+    if fmt not in FORMATS:
+        raise ValueError(f"unsupported format: {fmt}")
+    ext, mime, args = FORMATS[fmt]
+    if args is None:
+        return wav_bytes, ext, mime
+    ffmpeg = find_ffmpeg()
+    if not ffmpeg:
+        raise RuntimeError("ffmpeg not available; install imageio-ffmpeg or ffmpeg")
+    safe_title = "".join(c for c in title if c.isalnum() or c in " -_.")[:80] or "RushDAW"
+    with tempfile.TemporaryDirectory(prefix="rushdaw_") as tmp:
+        src = os.path.join(tmp, "in.wav")
+        dst = os.path.join(tmp, "out." + ext)
+        with open(src, "wb") as f:
+            f.write(wav_bytes)
+        cmd = [ffmpeg, "-y", "-hide_banner", "-loglevel", "error", "-i", src]
+        if args == "VIDEO":
+            # music video: animated waveform on dark background
+            cmd += [
+                "-filter_complex",
+                "[0:a]showwaves=s=1280x720:mode=cline:rate=30:colors=0x00e5ff|0xffffff,format=yuv420p[v]",
+                "-map", "[v]", "-map", "0:a",
+                "-c:v", "libx264", "-preset", "veryfast", "-crf", "23",
+                "-c:a", "aac", "-b:a", "256k", "-shortest", "-movflags", "+faststart",
+            ]
+        else:
+            cmd += args
+        cmd += ["-metadata", f"title={safe_title}", "-metadata", "encoder=RushDAW", dst]
+        proc = subprocess.run(cmd, capture_output=True, timeout=900)
+        if proc.returncode != 0 or not os.path.exists(dst):
+            raise RuntimeError(proc.stderr.decode("utf-8", "replace")[-800:] or "ffmpeg failed")
+        with open(dst, "rb") as f:
+            return f.read(), ext, mime