Upload 6 files

app.py

@@ -7,6 +7,7 @@ import threading
 import time
 import uuid
 from pathlib import Path
+from urllib.request import urlretrieve
 from zipfile import ZIP_DEFLATED, ZipFile
 
 from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
@@ -45,6 +46,7 @@ ALLOWED_FORMATS = {
     "mp3",
 }
 JOB_TTL_SECONDS = 2 * 60 * 60
+DEFAULT_UVR_WORKER_URL = "https://jayman-neuralis-uvr-stem-worker.hf.space"
 
 app = FastAPI(title=APP_NAME)
 app.add_middleware(
@@ -253,51 +255,141 @@ def _find_uvr_stems(output_dir: Path) -> tuple[Path, Path]:
     return vocal, instrumental
 
 
+def _normalize_uvr_worker_url(value: str) -> str:
+    raw = (value or DEFAULT_UVR_WORKER_URL).strip()
+    marker = "huggingface.co/spaces/"
+    if marker in raw:
+        repo = raw.split(marker, 1)[1].split("?", 1)[0].split("#", 1)[0].strip("/")
+        parts = repo.split("/")
+        if len(parts) >= 2:
+            return f"https://{parts[0]}-{parts[1]}.hf.space"
+    return raw or DEFAULT_UVR_WORKER_URL
+
+
+def _flatten_gradio_outputs(value) -> list[str]:
+    paths = []
+    if value is None:
+        return paths
+    if isinstance(value, (str, Path)):
+        return [str(value)]
+    if isinstance(value, dict):
+        for key in ("path", "name", "url"):
+            item = value.get(key)
+            if item:
+                paths.append(str(item))
+        for item in value.values():
+            if isinstance(item, (dict, list, tuple)):
+                paths.extend(_flatten_gradio_outputs(item))
+        return paths
+    if isinstance(value, (list, tuple)):
+        for item in value:
+            paths.extend(_flatten_gradio_outputs(item))
+    return paths
+
+
+def _copy_gradio_output(value: str, output_dir: Path, index: int) -> Path | None:
+    raw = str(value or "").strip()
+    if not raw:
+        return None
+    suffix = Path(raw.split("?", 1)[0]).suffix.lower()
+    if suffix not in {".wav", ".mp3", ".flac"}:
+        suffix = ".wav"
+    raw_name = Path(raw.split("?", 1)[0]).name
+    target_name = _safe_name(raw_name or f"uvr-output-{index}{suffix}")
+    if Path(target_name).suffix.lower() not in {".wav", ".mp3", ".flac"}:
+        target_name = f"{Path(target_name).stem}{suffix}"
+    target = output_dir / target_name
+    if target.exists():
+        target = output_dir / f"{Path(target_name).stem}-{index}{Path(target_name).suffix}"
+    if raw.startswith(("http://", "https://")):
+        urlretrieve(raw, target)
+        return target
+    source = Path(raw)
+    if source.exists() and source.is_file():
+        if source.resolve() == target.resolve():
+            return target
+        shutil.copy2(source, target)
+        return target
+    return None
+
+
 def _run_audio_separator(input_path: Path, work_dir: Path, model: str, mode: str) -> dict:
-    if shutil.which("audio-separator") is None:
-        raise RuntimeError("UVR MDX is not installed on this worker yet. Use Demucs Standard/Fine-Tuned, or deploy a dedicated UVR test worker.")
     if mode != "fast-2stem":
         raise RuntimeError("UVR MDX test model currently supports fast-2stem vocal/instrumental output only")
     model_file = UVR_MODEL_FILES.get(model)
     if not model_file:
         raise RuntimeError(f"Unsupported UVR model: {model}")
 
-    output_dir = work_dir / "uvr-separated"
-    model_dir = Path(os.getenv("NEURALIS_UVR_MODEL_DIR", "/tmp/neuralis-uvr-models"))
-    output_dir.mkdir(parents=True, exist_ok=True)
-    model_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        from gradio_client import Client, handle_file
+    except Exception as exc:
+        raise RuntimeError("UVR MDX remote adapter needs gradio_client installed in the stem worker") from exc
 
-    cmd = [
-        "audio-separator",
-        str(input_path),
-        "--model_filename",
-        model_file,
-        "--output_dir",
-        str(output_dir),
-        "--model_file_dir",
-        str(model_dir),
-        "--output_format",
+    output_dir = work_dir / "uvr-remote-separated"
+    output_dir.mkdir(parents=True, exist_ok=True)
+    worker_url = _normalize_uvr_worker_url(os.getenv("NEURALIS_UVR_WORKER_URL", DEFAULT_UVR_WORKER_URL))
+    args = [
+        handle_file(str(input_path)),
+        ["vocal", "background"],
+        False,
+        False,
+        False,
+        False,
+        0.15,
+        0.7,
+        0.8,
+        0.2,
+        0.0,
+        0.0,
+        -18,
+        2.0,
+        5,
+        100,
+        0.0,
+        20,
+        20000,
+        0.15,
+        0.7,
+        0.15,
+        -18,
+        2.0,
+        5,
+        100,
+        0.0,
         "WAV",
     ]
-    if os.getenv("NEURALIS_UVR_USE_CUDA", "1").strip().lower() not in {"0", "false", "no", "off"}:
-        cmd.append("--use_cuda")
+    attempts = [
+        {"api_name": "/sound_separate"},
+        {"api_name": "/predict"},
+        *({"fn_index": index} for index in range(8)),
+    ]
 
     start = time.time()
-    proc = subprocess.run(
-        cmd,
-        cwd=work_dir,
-        text=True,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.STDOUT,
-        timeout=60 * 25,
-    )
-    if proc.returncode != 0:
-        raise RuntimeError(proc.stdout[-6000:])
+    errors = []
+    result = None
+    client = Client(worker_url)
+    for attempt in attempts:
+        try:
+            result = client.predict(*args, **attempt)
+            break
+        except Exception as exc:
+            errors.append(f"{attempt}: {str(exc)[:360]}")
+    if result is None:
+        detail = " | ".join(errors[-3:]) if errors else "No response from UVR worker"
+        raise RuntimeError(f"UVR MDX remote worker failed: {detail}")
+
+    copied = []
+    for index, path_value in enumerate(_flatten_gradio_outputs(result), start=1):
+        copied_path = _copy_gradio_output(path_value, output_dir, index)
+        if copied_path:
+            copied.append(copied_path)
+    if len(copied) < 2:
+        raise RuntimeError("UVR MDX remote worker returned no usable vocal/instrumental files")
 
     vocal_path, instrumental_path = _find_uvr_stems(output_dir)
     elapsed = time.time() - start
     (work_dir / "neuralis-stem-report.txt").write_text(
-        f"mode={mode}\nmodel={model}\nengine=audio-separator\nmodelFile={model_file}\nseconds={elapsed:.2f}\nsource={input_path.name}\n",
+        f"mode={mode}\nmodel={model}\nengine=remote-gradio-uvr\nworker={worker_url}\nmodelFile={model_file}\nseconds={elapsed:.2f}\nsource={input_path.name}\n",
         encoding="utf-8",
     )
     return {

requirements.txt

@@ -4,3 +4,4 @@ python-multipart==0.0.20
 numpy<2
 demucs==4.0.1
 soundfile==0.12.1
+gradio_client