voxsplit 0.1.0__py3-none-any.whl

backend/engine.py

@@ -0,0 +1,119 @@
+"""Engine wrapper around python-audio-separator.
+
+The heavy audio_separator import happens lazily so the FastAPI app,
+tests, and CI can run without torch installed.
+"""
+
+import logging
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+MODELS = [
+    {"id": "UVR-MDX-NET-Inst_HQ_3.onnx", "family": "MDX-Net", "stems": 2, "note": "HQ instrumental/vocals"},
+    {"id": "Kim_Vocal_2.onnx", "family": "MDX-Net", "stems": 2, "note": "Vocals, stronger on male vocals"},
+    {"id": "UVR_MDXNET_KARA_2.onnx", "family": "MDX-Net", "stems": 2, "note": "Karaoke-optimized"},
+    {
+        "id": "mel_band_roformer_karaoke_aufr33_viperx_sdr_10.1956.ckpt",
+        "family": "Mel-Band RoFormer",
+        "stems": 2,
+        "note": "SOTA karaoke (~1GB download)",
+    },
+    {
+        "id": "mel_band_roformer_karaoke_becruily.ckpt",
+        "family": "Mel-Band RoFormer",
+        "stems": 2,
+        "note": "SOTA karaoke alt (~1GB download)",
+    },
+    {
+        "id": "vocals_mel_band_roformer.ckpt",
+        "family": "Mel-Band RoFormer",
+        "stems": 2,
+        "note": "SOTA vocals (~1GB download)",
+    },
+    {"id": "htdemucs_4s.yaml", "family": "Demucs", "stems": 4, "note": "Vocals/drums/bass/other"},
+]
+
+DEFAULT_MODEL = "UVR-MDX-NET-Inst_HQ_3.onnx"
+
+PHASES = ("loading_model", "separating", "writing")
+
+
+def list_models() -> list[dict]:
+    return MODELS
+
+
+def is_known_model(model: str) -> bool:
+    return model in {m["id"] for m in MODELS}
+
+
+def detect_accelerator() -> str:
+    try:
+        import torch
+
+        if torch.cuda.is_available():
+            return "cuda"
+        if getattr(torch.backends, "mps", None) and torch.backends.mps.is_available():
+            return "mps"
+    except Exception:
+        pass
+    return "cpu"
+
+
+def _install_progress_hook(progress_cb):
+    """Patch tqdm inside torch-based architectures so chunk loops report progress.
+
+    Returns a list of (module, attr, original) tuples to restore in finally.
+    MDX-Net models run through onnxruntime without tqdm loops, so callers get
+    phase-level progress only for that family.
+    """
+    from audio_separator.separator.architectures import demucs_separator, mdxc_separator
+    from tqdm import tqdm
+
+    class HookedTqdm(tqdm):
+        def update(self, n=1):
+            super().update(n)
+            if self.total:
+                progress_cb("separating", min(100.0, 100.0 * self.n / self.total))
+
+    saved = []
+    for module in (mdxc_separator, demucs_separator):
+        if hasattr(module, "tqdm"):
+            saved.append((module, "tqdm", module.tqdm))
+            module.tqdm = HookedTqdm
+    return saved
+
+
+def run_separation(
+    input_path: Path,
+    output_dir: Path,
+    model: str,
+    model_dir: Path,
+    progress_cb=None,
+) -> list[Path]:
+    from audio_separator.separator import Separator
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+
+    def report(phase: str, percent: float | None = None) -> None:
+        if progress_cb:
+            progress_cb(phase, percent)
+
+    report("loading_model", 0.0)
+    logger.info("Loading model %s", model)
+    saved = _install_progress_hook(report)
+    try:
+        separator = Separator(
+            model_file_dir=str(model_dir),
+            output_dir=str(output_dir),
+            output_format="WAV",
+        )
+        separator.load_model(model_filename=model)
+        output_files = separator.separate(str(input_path))
+    finally:
+        for module, attr, original in saved:
+            setattr(module, attr, original)
+    report("writing", 99.0)
+    logger.info("Separation produced %d files", len(output_files))
+    return [output_dir / Path(f).name for f in output_files]

backend/frontend/app.js

@@ -0,0 +1,183 @@
+const fileInput = document.getElementById("file-input");
+const browseBtn = document.getElementById("browse");
+const dropzone = document.getElementById("dropzone");
+const fileName = document.getElementById("file-name");
+const modelSelect = document.getElementById("model-select");
+const splitBtn = document.getElementById("split-btn");
+const jobList = document.getElementById("job-list");
+
+let selectedFile = null;
+const pollers = new Map();
+
+async function loadModels() {
+  const res = await fetch("/api/models");
+  const models = await res.json();
+  for (const m of models) {
+    const opt = document.createElement("option");
+    opt.value = m.id;
+    opt.textContent = `${m.id} — ${m.note} (${m.stems} stems)`;
+    modelSelect.appendChild(opt);
+  }
+}
+
+browseBtn.addEventListener("click", () => fileInput.click());
+
+fileInput.addEventListener("change", () => {
+  selectedFile = fileInput.files[0] || null;
+  fileName.textContent = selectedFile ? selectedFile.name : "";
+  splitBtn.disabled = !selectedFile;
+});
+
+["dragenter", "dragover"].forEach((evt) =>
+  dropzone.addEventListener(evt, (e) => {
+    e.preventDefault();
+    dropzone.classList.add("dragover");
+  })
+);
+
+["dragleave", "drop"].forEach((evt) =>
+  dropzone.addEventListener(evt, (e) => {
+    e.preventDefault();
+    dropzone.classList.remove("dragover");
+  })
+);
+
+dropzone.addEventListener("drop", (e) => {
+  const file = e.dataTransfer.files[0];
+  if (file) {
+    selectedFile = file;
+    fileName.textContent = file.name;
+    splitBtn.disabled = false;
+  }
+});
+
+splitBtn.addEventListener("click", async () => {
+  if (!selectedFile) return;
+  splitBtn.disabled = true;
+  splitBtn.textContent = "Uploading…";
+  try {
+    const form = new FormData();
+    form.append("file", selectedFile);
+    form.append("model", modelSelect.value);
+    const res = await fetch("/api/jobs", { method: "POST", body: form });
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({ detail: res.statusText }));
+      throw new Error(err.detail || "Upload failed");
+    }
+    const job = await res.json();
+    addJobCard(job);
+    pollJob(job.id);
+    selectedFile = null;
+    fileInput.value = "";
+    fileName.textContent = "";
+  } catch (err) {
+    alert(err.message);
+  } finally {
+    splitBtn.disabled = !selectedFile;
+    splitBtn.textContent = "Split";
+  }
+});
+
+function stemLabel(path) {
+  const base = path.split("/").pop();
+  const m = base.match(/_(vocals|instrumental|drums|bass|other|no_vocals)\./i);
+  return m ? m[1].replace("_", " ") : base;
+}
+
+function addJobCard(job) {
+  const empty = jobList.querySelector(".empty");
+  if (empty) empty.remove();
+
+  const div = document.createElement("div");
+  div.className = "job";
+  div.id = `job-${job.id}`;
+  div.innerHTML = `
+    <div class="job-head">
+      <span class="job-title">${escapeHtml(job.filename)}</span>
+      <span class="job-model">${escapeHtml(job.model)}</span>
+      <span class="status ${job.status}">${job.status}</span>
+    </div>
+    <div class="job-body"></div>
+  `;
+  jobList.prepend(div);
+  renderJobBody(div, job);
+}
+
+const PHASE_LABELS = {
+  loading_model: "Loading model…",
+  separating: "Separating…",
+  writing: "Writing stems…",
+};
+
+function renderJobBody(card, job) {
+  const body = card.querySelector(".job-body");
+  const status = card.querySelector(".status");
+  status.textContent = job.status;
+  status.className = `status ${job.status}`;
+
+  if (job.status === "failed") {
+    body.innerHTML = `<p class="job-error">${escapeHtml(job.error || "Unknown error")}</p>`;
+  } else if (job.status === "completed") {
+    const ul = document.createElement("ul");
+    ul.className = "stems";
+    for (const f of job.files) {
+      const name = f.split("/").pop();
+      const li = document.createElement("li");
+      li.innerHTML = `
+        <span class="stem-name">${escapeHtml(stemLabel(name))}</span>
+        <audio controls preload="none" src="/api/jobs/${job.id}/files/${encodeURIComponent(name)}"></audio>
+        <a class="download" href="/api/jobs/${job.id}/files/${encodeURIComponent(name)}" download>download</a>
+      `;
+      ul.appendChild(li);
+    }
+    body.innerHTML = "";
+    body.appendChild(ul);
+  } else {
+    const phase = PHASE_LABELS[job.phase] || (job.status === "queued" ? "Waiting…" : "Processing…");
+    let bar;
+    if (job.progress != null) {
+      bar = `<div class="bar"><div class="bar-fill" style="width:${job.progress}%"></div></div>`;
+    } else {
+      bar = `<div class="bar"><div class="bar-fill indeterminate"></div></div>`;
+    }
+    body.innerHTML = `<p class="phase">${escapeHtml(phase)}</p>${bar}`;
+  }
+}
+
+function pollJob(jobId) {
+  if (pollers.has(jobId)) return;
+  const timer = setInterval(async () => {
+    const res = await fetch(`/api/jobs/${jobId}`);
+    if (!res.ok) {
+      clearInterval(timer);
+      pollers.delete(jobId);
+      return;
+    }
+    const job = await res.json();
+    const card = document.getElementById(`job-${jobId}`);
+    if (card) renderJobBody(card, job);
+    if (job.status === "completed" || job.status === "failed") {
+      clearInterval(timer);
+      pollers.delete(jobId);
+    }
+  }, 1500);
+  pollers.set(jobId, timer);
+}
+
+async function loadExistingJobs() {
+  const res = await fetch("/api/jobs");
+  const jobs = await res.json();
+  for (const job of jobs.slice(0, 20)) {
+    addJobCard(job);
+    if (job.status === "queued" || job.status === "processing") pollJob(job.id);
+  }
+}
+
+function escapeHtml(s) {
+  return s.replace(/[&<>"']/g, (c) => ({
+    "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;",
+  }[c]));
+}
+
+loadModels();
+loadExistingJobs();

backend/frontend/index.html

@@ -0,0 +1,45 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>VoxSplit — AI Stem Separation</title>
+  <link rel="stylesheet" href="/style.css" />
+</head>
+<body>
+  <header>
+    <h1><span class="accent">Vox</span>Split</h1>
+    <p class="tagline">Local-first AI stem separation</p>
+  </header>
+
+  <main>
+    <section class="card" id="dropzone" aria-label="Upload a song">
+      <input type="file" id="file-input" accept=".wav,.mp3,.flac,.ogg,.m4a,.aac,.wma" hidden />
+      <p class="drop-msg">Drop an audio file here, or <button type="button" class="link" id="browse">browse</button></p>
+      <p class="file-name" id="file-name"></p>
+      <div class="controls">
+        <label for="model-select">Model</label>
+        <select id="model-select"></select>
+        <button type="button" id="split-btn" class="primary" disabled>Split</button>
+      </div>
+    </section>
+
+    <section id="jobs">
+      <h2>Jobs</h2>
+      <div id="job-list" class="job-list">
+        <p class="empty">No jobs yet — split your first song above.</p>
+      </div>
+    </section>
+  </main>
+
+  <footer>
+    <p>
+      VoxSplit is free software (MIT). Powered by
+      <a href="https://github.com/nomadkaraoke/python-audio-separator" target="_blank" rel="noopener">python-audio-separator</a>.
+      Inspired by <a href="https://github.com/Anjok07/ultimatevocalremovergui" target="_blank" rel="noopener">Ultimate Vocal Remover</a>.
+    </p>
+  </footer>
+
+  <script src="/app.js"></script>
+</body>
+</html>

backend/frontend/style.css

@@ -0,0 +1,175 @@
+:root {
+  --bg: #0f1115;
+  --card: #171a21;
+  --border: #262b36;
+  --text: #e6e9ef;
+  --muted: #8b93a3;
+  --accent: #7c6cff;
+  --accent-2: #4ecdc4;
+  --danger: #ff6b6b;
+  --ok: #4caf7d;
+}
+
+* { box-sizing: border-box; }
+
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+}
+
+header {
+  text-align: center;
+  padding: 2.5rem 1rem 1rem;
+}
+
+h1 { font-size: 2.2rem; margin: 0; letter-spacing: -0.02em; }
+.accent { color: var(--accent); }
+.tagline { color: var(--muted); margin: 0.3rem 0 0; }
+
+main {
+  width: 100%;
+  max-width: 720px;
+  margin: 0 auto;
+  padding: 1rem;
+  flex: 1;
+}
+
+.card {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 1.5rem;
+}
+
+#dropzone { border-style: dashed; border-width: 2px; transition: border-color 0.15s; }
+#dropzone.dragover { border-color: var(--accent); }
+.drop-msg { text-align: center; color: var(--muted); margin: 0.5rem 0; }
+.file-name { text-align: center; font-weight: 600; min-height: 1.4em; margin: 0.5rem 0; }
+
+.link {
+  background: none;
+  border: none;
+  color: var(--accent);
+  cursor: pointer;
+  font: inherit;
+  text-decoration: underline;
+  padding: 0;
+}
+
+.controls {
+  display: flex;
+  gap: 0.75rem;
+  align-items: center;
+  justify-content: center;
+  margin-top: 1rem;
+  flex-wrap: wrap;
+}
+
+.controls label { color: var(--muted); }
+
+select, button {
+  font: inherit;
+  border-radius: 8px;
+  border: 1px solid var(--border);
+  background: var(--bg);
+  color: var(--text);
+  padding: 0.5rem 0.9rem;
+}
+
+button.primary {
+  background: var(--accent);
+  border-color: var(--accent);
+  color: white;
+  font-weight: 600;
+  cursor: pointer;
+}
+button.primary:disabled { opacity: 0.45; cursor: not-allowed; }
+
+h2 { font-size: 1.1rem; color: var(--muted); margin-top: 2rem; }
+
+.job {
+  background: var(--card);
+  border: 1px solid var(--border);
+  border-radius: 12px;
+  padding: 1rem 1.25rem;
+  margin-bottom: 0.75rem;
+}
+
+.job-head {
+  display: flex;
+  justify-content: space-between;
+  align-items: baseline;
+  gap: 1rem;
+}
+
+.job-title { font-weight: 600; overflow-wrap: anywhere; }
+.job-model { color: var(--muted); font-size: 0.85rem; }
+
+.status { font-size: 0.8rem; font-weight: 700; text-transform: uppercase; letter-spacing: 0.05em; }
+.status.queued { color: var(--muted); }
+.status.processing { color: var(--accent-2); }
+.status.completed { color: var(--ok); }
+.status.failed { color: var(--danger); }
+
+.job-error { color: var(--danger); font-size: 0.85rem; margin-top: 0.5rem; overflow-wrap: anywhere; }
+
+.stems { list-style: none; padding: 0; margin: 0.75rem 0 0; }
+.stems li {
+  display: flex;
+  align-items: center;
+  gap: 0.75rem;
+  padding: 0.4rem 0;
+  border-top: 1px solid var(--border);
+}
+.stems li audio { flex: 1; height: 36px; }
+
+.stem-name {
+  font-size: 0.85rem;
+  color: var(--muted);
+  min-width: 30%;
+  overflow-wrap: anywhere;
+}
+
+a.download { color: var(--accent-2); font-size: 0.85rem; text-decoration: none; }
+a.download:hover { text-decoration: underline; }
+
+.empty { color: var(--muted); text-align: center; padding: 1.5rem 0; }
+
+.phase { color: var(--muted); font-size: 0.85rem; margin: 0.5rem 0; }
+
+.bar {
+  height: 8px;
+  border-radius: 4px;
+  background: var(--border);
+  overflow: hidden;
+}
+
+.bar-fill {
+  height: 100%;
+  background: linear-gradient(90deg, var(--accent), var(--accent-2));
+  border-radius: 4px;
+  transition: width 0.5s ease;
+}
+
+.bar-fill.indeterminate {
+  width: 35%;
+  animation: slide 1.2s ease-in-out infinite;
+}
+
+@keyframes slide {
+  0% { margin-left: -35%; }
+  100% { margin-left: 100%; }
+}
+
+footer {
+  text-align: center;
+  color: var(--muted);
+  font-size: 0.8rem;
+  padding: 1.5rem;
+}
+footer a { color: var(--accent-2); }

backend/jobs.py

@@ -0,0 +1,97 @@
+"""Thread-safe in-memory job store with a single-worker executor."""
+
+import threading
+import time
+import uuid
+from collections.abc import Callable
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from backend import engine
+
+
+@dataclass
+class Job:
+    id: str
+    filename: str
+    model: str
+    status: str = "queued"
+    phase: str = "queued"
+    progress: float | None = None
+    error: str | None = None
+    files: list[str] = field(default_factory=list)
+    created_at: float = field(default_factory=time.time)
+    finished_at: float | None = None
+
+    def to_dict(self) -> dict:
+        return {
+            "id": self.id,
+            "filename": self.filename,
+            "model": self.model,
+            "status": self.status,
+            "phase": self.phase,
+            "progress": self.progress,
+            "error": self.error,
+            "files": self.files,
+            "created_at": self.created_at,
+            "finished_at": self.finished_at,
+        }
+
+
+class JobStore:
+    def __init__(self, output_dir: Path, model_dir: Path):
+        self._jobs: dict[str, Job] = {}
+        self._lock = threading.Lock()
+        self._executor = ThreadPoolExecutor(max_workers=1)
+        self.output_dir = output_dir
+        self.model_dir = model_dir
+
+    def create(self, filename: str, model: str) -> Job:
+        job = Job(id=uuid.uuid4().hex[:12], filename=filename, model=model)
+        with self._lock:
+            self._jobs[job.id] = job
+        return job
+
+    def get(self, job_id: str) -> Job | None:
+        with self._lock:
+            return self._jobs.get(job_id)
+
+    def remove(self, job_id: str) -> None:
+        with self._lock:
+            self._jobs.pop(job_id, None)
+
+    def list(self) -> list[Job]:
+        with self._lock:
+            return sorted(self._jobs.values(), key=lambda j: j.created_at, reverse=True)
+
+    def submit(self, job: Job, input_path: Path) -> None:
+        self._executor.submit(self._run, job, input_path)
+
+    def _run(self, job: Job, input_path: Path) -> None:
+        job.status = "processing"
+
+        def on_progress(phase: str, percent: float | None = None) -> None:
+            with self._lock:
+                job.phase = phase
+                job.progress = percent
+
+        try:
+            out_dir = self.output_dir / job.id
+            results = engine.run_separation(
+                input_path, out_dir, job.model, self.model_dir, progress_cb=on_progress
+            )
+            job.files = [str(p) for p in results]
+            job.status = "completed"
+            job.phase = "done"
+            job.progress = 100.0
+        except Exception as exc:
+            job.status = "failed"
+            job.phase = "error"
+            job.error = f"{type(exc).__name__}: {exc}"
+        finally:
+            job.finished_at = time.time()
+
+
+def make_runner(store: JobStore) -> Callable[[Job, Path], None]:
+    return store.submit

backend/main.py

@@ -0,0 +1,121 @@
+import argparse
+import os
+import shutil
+from pathlib import Path
+
+from fastapi import FastAPI, File, Form, HTTPException, UploadFile
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from backend import engine
+from backend.jobs import JobStore
+
+BASE_DIR = Path(__file__).resolve().parent
+DATA_DIR = Path(os.environ.get("VOXSPLIT_DATA_DIR", Path.cwd() / "data"))
+UPLOAD_DIR = DATA_DIR / "uploads"
+OUTPUT_DIR = DATA_DIR / "output"
+MODEL_DIR = DATA_DIR / "models"
+FRONTEND_DIR = BASE_DIR / "frontend"
+
+ALLOWED_EXTENSIONS = {".wav", ".mp3", ".flac", ".ogg", ".m4a", ".aac", ".wma"}
+MAX_UPLOAD_BYTES = 500 * 1024 * 1024
+
+app = FastAPI(title="VoxSplit", description="Local-first AI stem separation", version="0.1.0")
+store = JobStore(output_dir=OUTPUT_DIR, model_dir=MODEL_DIR)
+
+
+@app.get("/api/health")
+def health() -> dict:
+    return {"status": "ok", "version": app.version, "accelerator": engine.detect_accelerator()}
+
+
+@app.get("/api/models")
+def models() -> list[dict]:
+    return engine.list_models()
+
+
+@app.get("/api/jobs")
+def list_jobs() -> list[dict]:
+    return [job.to_dict() for job in store.list()]
+
+
+@app.post("/api/jobs")
+async def create_job(file: UploadFile = File(...), model: str = Form(engine.DEFAULT_MODEL)) -> dict:
+    if not engine.is_known_model(model):
+        raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
+    suffix = Path(file.filename or "").suffix.lower()
+    if suffix not in ALLOWED_EXTENSIONS:
+        raise HTTPException(status_code=400, detail=f"Unsupported file type: {suffix or 'unknown'}")
+
+    job = store.create(filename=file.filename or "upload", model=model)
+    input_path = UPLOAD_DIR / f"{job.id}{suffix}"
+    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+    size = 0
+    with input_path.open("wb") as out:
+        while chunk := await file.read(1024 * 1024):
+            size += len(chunk)
+            if size > MAX_UPLOAD_BYTES:
+                input_path.unlink(missing_ok=True)
+                raise HTTPException(status_code=413, detail="File too large (500MB limit)")
+            out.write(chunk)
+    store.submit(job, input_path)
+    return job.to_dict()
+
+
+@app.get("/api/jobs/{job_id}")
+def get_job(job_id: str) -> dict:
+    job = store.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return job.to_dict()
+
+
+@app.delete("/api/jobs/{job_id}")
+def delete_job(job_id: str) -> dict:
+    job = store.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+    shutil.rmtree(OUTPUT_DIR / job_id, ignore_errors=True)
+    store.remove(job_id)
+    return {"deleted": job_id}
+
+
+@app.get("/api/jobs/{job_id}/files/{name}", response_class=FileResponse)
+def job_file(job_id: str, name: str) -> FileResponse:
+    job = store.get(job_id)
+    if job is None:
+        raise HTTPException(status_code=404, detail="Job not found")
+    path = (OUTPUT_DIR / job_id / name).resolve()
+    if not str(path).startswith(str((OUTPUT_DIR / job_id).resolve())):
+        raise HTTPException(status_code=400, detail="Invalid path")
+    if not path.is_file():
+        raise HTTPException(status_code=404, detail="File not found")
+    return FileResponse(path, filename=name)
+
+
+app.mount("/", StaticFiles(directory=str(FRONTEND_DIR), html=True), name="frontend")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="voxsplit",
+        description="Local-first AI stem separation server",
+    )
+    parser.add_argument("command", nargs="?", default="serve", choices=["serve"])
+    parser.add_argument("--host", default="127.0.0.1")
+    parser.add_argument("--port", type=int, default=8399)
+    try:
+        from importlib.metadata import version
+
+        parser.add_argument("--version", action="version", version=f"voxsplit {version('voxsplit')}")
+    except Exception:
+        pass
+    args = parser.parse_args()
+
+    import uvicorn
+
+    uvicorn.run(app, host=args.host, port=args.port)
+
+
+if __name__ == "__main__":
+    main()

voxsplit-0.1.0.dist-info/METADATA

@@ -0,0 +1,162 @@
+Metadata-Version: 2.4
+Name: voxsplit
+Version: 0.1.0
+Summary: Local-first AI stem separation with a modern web UI
+Author: Michael Borck
+License: MIT License
+        
+        Copyright (c) 2026 Michael Borck
+        
+        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.
+        
+Project-URL: Homepage, https://voxsplit.borck.dev
+Project-URL: Repository, https://github.com/michael-borck/voxsplit
+Project-URL: Issues, https://github.com/michael-borck/voxsplit/issues
+Keywords: audio,stems,source-separation,vocal-remover,karaoke,demucs,roformer,music
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Sound/Audio
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.115
+Requires-Dist: uvicorn[standard]>=0.30
+Requires-Dist: python-multipart>=0.0.9
+Requires-Dist: audio-separator[cpu]>=0.30
+Requires-Dist: audioread>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: ruff>=0.6; extra == "dev"
+Requires-Dist: httpx>=0.27; extra == "dev"
+Dynamic: license-file
+
+# VoxSplit
+
+**[voxsplit.borck.dev](https://voxsplit.borck.dev)** — hear real separation output, then self-host.
+
+Local-first AI stem separation with a modern web UI. Drop in a song, get back
+vocals, instrumental, or full 4-stem splits — everything runs on your own
+machine, no accounts, no uploads to the cloud.
+
+VoxSplit is a greenfield web app built on proven open-source separation
+engines. It is inspired by [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui)
+and stands on the shoulders of that project and its model authors.
+
+## Status
+
+Working proof of concept: upload → separate with per-job progress → play/download
+stems. Models auto-use the best available accelerator: CUDA on Linux/NVIDIA,
+MPS on Apple Silicon (torch-based models), CPU everywhere.
+
+## Models
+
+Weights are fetched on demand (first use of each model) into `data/models/`
+from the community model repos maintained by the UVR and python-audio-separator
+projects. No manual downloads needed.
+
+| Model | Family | Stems | Notes |
+|---|---|---|---|
+| Mel-Band RoFormer (aufr33/viperx) | RoFormer | 2 | SOTA karaoke quality |
+| Mel-Band RoFormer (becruily) | RoFormer | 2 | SOTA karaoke alt |
+| Mel-Band RoFormer (KimberleyJSN) | RoFormer | 2 | SOTA vocals |
+| UVR-MDX-NET-Inst HQ 3 | MDX-Net | 2 | Fast, high quality |
+| Kim Vocal 2 | MDX-Net | 2 | Vocals, male-leaning |
+| UVR MDXNET Kara 2 | MDX-Net | 2 | Karaoke-optimized |
+| htdemucs_4s | Demucs | 4 | Vocals/drums/bass/other |
+
+Accelerator notes: RoFormer and Demucs run on CUDA/MPS automatically. MDX-Net
+runs via onnxruntime — CPU on macOS, CUDA on Linux with `audio-separator[gpu]`.
+
+## Quickstart
+
+Requires Python 3.10+ and [uv](https://docs.astral.sh/uv/) (or plain `pip` —
+see note below).
+
+```bash
+git clone https://github.com/michael-borck/voxsplit
+cd voxsplit
+uv venv
+source .venv/bin/activate
+uv pip install -e .
+voxsplit
+```
+
+Without uv: `python3 -m venv .venv && source .venv/bin/activate && pip install -e .`
+
+Open http://127.0.0.1:8399, drop a `.wav`/`.mp3`/`.flac`, pick a model, hit
+**Split**. The first run downloads the selected model (~60 MB) to `data/models/`.
+
+## Architecture
+
+```
+browser (vanilla JS) ──► FastAPI (backend/main.py)
+                            ├── jobs.py     thread-safe job store, 1-worker queue
+                            ├── engine.py   python-audio-separator wrapper (lazy import)
+                            └── data/       uploads, outputs, model weights
+```
+
+- **REST API**: `POST /api/jobs` (upload + model), `GET /api/jobs/{id}` (status),
+  `GET /api/jobs/{id}/files/{name}` (stream stem), `DELETE /api/jobs/{id}`.
+- **Engines**: models run via `python-audio-separator`, which supports UVR's
+  MDX-Net/VR models, Demucs, and Mel-Band RoFormers.
+
+## Credits
+
+This project exists because of the people who built the models and the
+original app:
+
+- **Anjok07 & aufr33** — [Ultimate Vocal Remover GUI](https://github.com/Anjok07/ultimatevocalremovergui),
+  the project that made high-quality local stem separation accessible.
+- **nomadkaraoke** — [python-audio-separator](https://github.com/nomadkaraoke/python-audio-separator),
+  the maintained headless engine VoxSplit wraps.
+- **ZFTurbo** — MDX23C weights and [Music-Source-Separation-Training](https://github.com/ZFTurbo/Music-Source-Separation-Training).
+- **Kuielab & Woosung Choi** — original MDX-Net AI code.
+- **tsurumeso** — original VR architecture code.
+- **Alexandre Défossez & Meta (Demucs)** — Demucs AI code.
+- **Bas Curtiz** — original UVR logo/icon design.
+
+## Deployment (NVIDIA)
+
+On a Linux box with NVIDIA GPUs and Docker + nvidia-container-toolkit:
+
+```bash
+cd deploy
+docker compose up -d --build
+```
+
+Then browse to `http://<box-ip>:8399`. Model weights persist in `deploy/data/`.
+
+## Roadmap
+
+- [x] Per-job progress reporting (tqdm hooks on torch models)
+- [x] Mel-Band RoFormer models (current SOTA)
+- [x] Apple Silicon MPS acceleration (automatic for torch models)
+- [ ] Ensemble mode + post-processing (from UVR's playbook)
+- [ ] Optional Tauri desktop wrapper
+
+## License
+
+MIT — see [LICENSE](LICENSE).

voxsplit-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+backend/engine.py,sha256=MXcFCZVnGl_81TOmlD4VuYpg6fA1jxrg_Z4wOOaEzGA,3700
+backend/jobs.py,sha256=OS0VUPB3xtXpfvrZtKC9qh63PvoRhohBUKXtkkQMxbE,2962
+backend/main.py,sha256=Hnzsoan_C-aFld96HAZpRA-eSos6kBlgZDoyPBeDSmc,4032
+backend/frontend/app.js,sha256=hAcI03-ekYT_I-5WkviUPoUuXx14x82rQ1c2_1IBui8,5606
+backend/frontend/index.html,sha256=wty21_JYun85CjCGl2z8C_qJaqgfLM247u_NtK9O1Ic,1569
+backend/frontend/style.css,sha256=I82d0tLGkvkwugLougbrok2CGHTtNwtI2e-A3Zm2x6o,3827
+voxsplit-0.1.0.dist-info/licenses/LICENSE,sha256=tP28nznO05HKBQN8uZ9NSvmcpzCWMj4P8e6F7IDj24Q,1070
+voxsplit-0.1.0.dist-info/METADATA,sha256=htAnLklKxWH9SqjqyahkU0KYskTXa5SWHx0QyOsxcAE,6710
+voxsplit-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+voxsplit-0.1.0.dist-info/entry_points.txt,sha256=j3NUBDCmkmjaEq9I547OXLHUEKzRaPYrkWqfkqUrBOA,47
+voxsplit-0.1.0.dist-info/top_level.txt,sha256=o0r_qMzzBDDtK9APrv2QVcIw9oc00JRmCEsTE2-AFr0,8
+voxsplit-0.1.0.dist-info/RECORD,,

voxsplit-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

voxsplit-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+voxsplit = backend.main:main

voxsplit-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Michael Borck
+
+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.

voxsplit-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+backend