Upload 3 files

DEPLOY.md

@@ -0,0 +1,85 @@
+# Deploying to jayman/neuralis-stem-worker
+
+Upload these files into the root of the Hugging Face Space:
+
+- `Dockerfile`
+- `README.md`
+- `app.py`
+- `requirements.txt`
+- `.dockerignore`
+
+Keep `.gitignore` locally; it does not need to be uploaded.
+
+## Hugging Face Settings
+
+In Space settings, add this secret:
+
+```text
+NEURALIS_STEM_API_KEY
+```
+
+Start on CPU Basic only to confirm the Docker build. For real testing, switch hardware to:
+
+```text
+Nvidia T4 small
+```
+
+Set sleep time to 15 or 30 minutes to avoid paying while idle.
+
+## Test URLs
+
+Health:
+
+```text
+https://jayman-neuralis-stem-worker.hf.space/health
+```
+
+Browser upload page:
+
+```text
+https://jayman-neuralis-stem-worker.hf.space/
+```
+
+The browser page now uses a job endpoint and shows upload/separation/download progress.
+
+## API Test
+
+Use the same key you saved in `NEURALIS_STEM_API_KEY`.
+
+Fast 2-stem test:
+
+```bash
+curl -L \
+  -H "X-Neuralis-Api-Key: your-key" \
+  -F "file=@song.wav" \
+  -F "mode=fast-2stem" \
+  -o neuralis-stems.zip \
+  https://jayman-neuralis-stem-worker.hf.space/separate
+```
+
+Progress API flow:
+
+```bash
+curl -L \
+  -H "X-Neuralis-Api-Key: your-key" \
+  -F "file=@song.wav" \
+  -F "mode=fast-2stem" \
+  https://jayman-neuralis-stem-worker.hf.space/jobs
+```
+
+Then poll the returned job ID:
+
+```bash
+curl -L https://jayman-neuralis-stem-worker.hf.space/jobs/JOB_ID
+```
+
+Premium 4-stem test:
+
+```bash
+curl -L \
+  -H "X-Neuralis-Api-Key: your-key" \
+  -F "file=@song.wav" \
+  -F "mode=premium-4stem" \
+  -o neuralis-stems-premium.zip \
+  https://jayman-neuralis-stem-worker.hf.space/separate
+```

README.md

@@ -55,7 +55,15 @@ Health:
 GET /health
 ```
 
-Separate audio:
+Browser/progress workflow:
+
+```text
+POST /jobs
+GET /jobs/{job_id}
+GET /jobs/{job_id}/download
+```
+
+Direct separate audio endpoint:
 
 ```text
 POST /separate
@@ -67,6 +75,8 @@ Form fields:
 - `mode`: optional, `fast-2stem` or `premium-4stem`
 - `model`: optional, defaults to `htdemucs`
 
+The browser page uses `/jobs` so it can show progress while separation is running. `/separate` remains available for direct API callers that want one request returning a ZIP.
+
 ## Suggested Hardware
 
 Start on CPU Basic to confirm the app builds, then switch to Nvidia T4 small for real stem separation tests.

app.py

@@ -3,6 +3,7 @@ import os
 import shutil
 import subprocess
 import tempfile
+import threading
 import time
 import uuid
 from pathlib import Path
@@ -27,8 +28,11 @@ ALLOWED_MODES = {
     "fast-2stem",
     "premium-4stem",
 }
+JOB_TTL_SECONDS = 2 * 60 * 60
 
 app = FastAPI(title=APP_NAME)
+JOBS = {}
+JOBS_LOCK = threading.Lock()
 
 
 def _client_key(request: Request) -> str:
@@ -46,6 +50,60 @@ def _require_api_key(request: Request) -> None:
         raise HTTPException(status_code=401, detail="Invalid Neuralis stem API key")
 
 
+def _check_api_key(request: Request, form_key: str = "") -> None:
+    expected = os.getenv("NEURALIS_STEM_API_KEY", "").strip()
+    if not expected:
+        return
+    header_key = _client_key(request)
+    if header_key and header_key != expected:
+        raise HTTPException(status_code=401, detail="Invalid Neuralis stem API key")
+    if not header_key and form_key.strip() != expected:
+        raise HTTPException(status_code=401, detail="Invalid Neuralis stem API key")
+
+
+def _set_job(job_id: str, **updates) -> None:
+    with JOBS_LOCK:
+        job = JOBS.get(job_id)
+        if not job:
+            return
+        job.update(updates)
+        job["updatedAt"] = time.time()
+
+
+def _public_job(job: dict) -> dict:
+    status = job.get("status", "queued")
+    progress = float(job.get("progress", 0))
+    if status == "processing":
+        elapsed = max(0.0, time.time() - float(job.get("startedAt", time.time())))
+        estimate = 120.0 if job.get("mode") == "fast-2stem" else 240.0
+        progress = max(progress, min(92.0, 18.0 + (elapsed / estimate) * 70.0))
+    return {
+        "id": job["id"],
+        "status": status,
+        "progress": round(progress, 1),
+        "stage": job.get("stage", ""),
+        "mode": job.get("mode", DEFAULT_MODE),
+        "model": job.get("model", DEFAULT_MODEL),
+        "source": job.get("source", ""),
+        "downloadUrl": job.get("downloadUrl"),
+        "error": job.get("error"),
+    }
+
+
+def _cleanup_old_jobs() -> None:
+    cutoff = time.time() - JOB_TTL_SECONDS
+    stale = []
+    with JOBS_LOCK:
+        for job_id, job in JOBS.items():
+            if float(job.get("createdAt", 0)) < cutoff:
+                stale.append((job_id, job.get("workDir")))
+        for job_id, _ in stale:
+            JOBS.pop(job_id, None)
+    for _, work_dir in stale:
+        if work_dir:
+            shutil.rmtree(work_dir, ignore_errors=True)
+
+
 def _safe_name(filename: str) -> str:
     name = Path(filename or "upload.wav").name
     keep = []
@@ -160,6 +218,44 @@ def _make_zip(run_info: dict, work_dir: Path, original_name: str, model: str, mo
     return zip_path
 
 
+def _process_job(job_id: str, input_path: Path, work_dir: Path, original_name: str, model: str, mode: str) -> None:
+    try:
+        _set_job(
+            job_id,
+            status="processing",
+            progress=16,
+            stage="Loading separation model",
+            startedAt=time.time(),
+        )
+        run_info = _run_demucs(input_path, work_dir, model, mode)
+        _set_job(job_id, progress=94, stage="Packing stems for download")
+        zip_path = _make_zip(run_info, work_dir, original_name, model, mode)
+        _set_job(
+            job_id,
+            status="ready",
+            progress=100,
+            stage="Stem separation complete",
+            zipPath=str(zip_path),
+            downloadUrl=f"/jobs/{job_id}/download",
+        )
+    except subprocess.TimeoutExpired as exc:
+        _set_job(
+            job_id,
+            status="failed",
+            progress=100,
+            stage="Stem separation timed out",
+            error=str(exc),
+        )
+    except Exception as exc:
+        _set_job(
+            job_id,
+            status="failed",
+            progress=100,
+            stage="Stem separation failed",
+            error=str(exc),
+        )
+
+
 @app.get("/", response_class=HTMLResponse)
 def index() -> str:
     return """
@@ -177,6 +273,13 @@ def index() -> str:
     label { display: block; margin: 20px 0 8px; font-size: 12px; letter-spacing: .14em; text-transform: uppercase; color: #b9d8d1; }
     input, select { width: 100%; box-sizing: border-box; padding: 12px; color: #fff; border: 1px solid #20343a; background: #070b0c; }
     button { margin-top: 22px; width: 100%; border: 0; padding: 14px; background: #2ff4be; color: #03110e; letter-spacing: .18em; text-transform: uppercase; cursor: pointer; }
+    button:disabled { opacity: .55; cursor: wait; }
+    .progress { display: none; margin-top: 24px; }
+    .track { height: 10px; overflow: hidden; border: 1px solid rgba(47, 244, 190, .25); background: #06100e; }
+    .bar { width: 0%; height: 100%; background: linear-gradient(90deg, #2ff4be, #ffd24a); transition: width .35s ease; }
+    .status { display: flex; justify-content: space-between; gap: 16px; margin-top: 10px; color: #b9d8d1; font-size: 13px; }
+    .download { display: none; margin-top: 18px; color: #2ff4be; letter-spacing: .12em; text-transform: uppercase; }
+    .error { display: none; margin-top: 18px; color: #ff8075; line-height: 1.4; }
     code { color: #2ff4be; }
   </style>
 </head>
@@ -184,7 +287,7 @@ def index() -> str:
   <main>
     <h1>Neuralis Stem Worker</h1>
     <p>Private Demucs worker for Neuralis. Use <code>/health</code> for status and <code>/separate</code> for API uploads.</p>
-    <form action="/separate" method="post" enctype="multipart/form-data">
+    <form id="stemForm">
       <label>API Key</label>
       <input name="apiKey" type="password" autocomplete="off" />
       <label>Mode</label>
@@ -194,9 +297,80 @@ def index() -> str:
       </select>
       <label>Audio File</label>
       <input name="file" type="file" accept="audio/*" required />
-      <button type="submit">Separate Stems</button>
+      <button id="submitButton" type="submit">Separate Stems</button>
     </form>
+    <section id="progressPanel" class="progress">
+      <div class="track"><div id="progressBar" class="bar"></div></div>
+      <div class="status">
+        <span id="statusText">Waiting</span>
+        <span id="percentText">0%</span>
+      </div>
+      <a id="downloadLink" class="download" href="#">Download Stems</a>
+      <div id="errorText" class="error"></div>
+    </section>
   </main>
+  <script>
+    const form = document.getElementById('stemForm');
+    const button = document.getElementById('submitButton');
+    const panel = document.getElementById('progressPanel');
+    const bar = document.getElementById('progressBar');
+    const statusText = document.getElementById('statusText');
+    const percentText = document.getElementById('percentText');
+    const downloadLink = document.getElementById('downloadLink');
+    const errorText = document.getElementById('errorText');
+
+    const setProgress = (value, stage) => {
+      const percent = Math.max(0, Math.min(100, Number(value) || 0));
+      bar.style.width = `${percent}%`;
+      percentText.textContent = `${Math.round(percent)}%`;
+      if (stage) statusText.textContent = stage;
+    };
+
+    const pollJob = async (id) => {
+      const res = await fetch(`/jobs/${id}`);
+      const job = await res.json();
+      setProgress(job.progress, job.stage || job.status);
+      if (job.status === 'ready') {
+        button.disabled = false;
+        button.textContent = 'Separate Stems';
+        downloadLink.href = job.downloadUrl;
+        downloadLink.style.display = 'inline-block';
+        statusText.textContent = 'Ready';
+        return;
+      }
+      if (job.status === 'failed') {
+        button.disabled = false;
+        button.textContent = 'Separate Stems';
+        errorText.textContent = job.error || 'Stem separation failed';
+        errorText.style.display = 'block';
+        return;
+      }
+      setTimeout(() => pollJob(id), 1500);
+    };
+
+    form.addEventListener('submit', async (event) => {
+      event.preventDefault();
+      button.disabled = true;
+      button.textContent = 'Processing';
+      panel.style.display = 'block';
+      downloadLink.style.display = 'none';
+      errorText.style.display = 'none';
+      setProgress(4, 'Uploading audio');
+
+      const data = new FormData(form);
+      const res = await fetch('/jobs', { method: 'POST', body: data });
+      const job = await res.json();
+      if (!res.ok) {
+        button.disabled = false;
+        button.textContent = 'Separate Stems';
+        errorText.textContent = job.detail || 'Upload failed';
+        errorText.style.display = 'block';
+        return;
+      }
+      setProgress(job.progress, job.stage || 'Queued');
+      pollJob(job.id);
+    });
+  </script>
 </body>
 </html>
 """
@@ -217,6 +391,87 @@ def health() -> JSONResponse:
     )
 
 
+@app.post("/jobs")
+async def create_job(
+    request: Request,
+    file: UploadFile = File(...),
+    model: str = Form(DEFAULT_MODEL),
+    mode: str = Form(DEFAULT_MODE),
+    apiKey: str = Form(""),
+) -> JSONResponse:
+    _check_api_key(request, apiKey)
+
+    selected_model = (model or DEFAULT_MODEL).strip()
+    if selected_model not in ALLOWED_MODELS:
+        raise HTTPException(status_code=400, detail=f"Unsupported model: {selected_model}")
+    selected_mode = (mode or DEFAULT_MODE).strip()
+    if selected_mode not in ALLOWED_MODES:
+        raise HTTPException(status_code=400, detail=f"Unsupported mode: {selected_mode}")
+
+    _cleanup_old_jobs()
+    original_name = _safe_name(file.filename)
+    suffix = Path(original_name).suffix or ".wav"
+    job_id = str(uuid.uuid4())
+    work_dir = Path(tempfile.mkdtemp(prefix=f"neuralis-stems-{job_id}-"))
+
+    try:
+        input_path = work_dir / f"source{suffix}"
+        await _save_upload(file, input_path)
+    except Exception:
+        shutil.rmtree(work_dir, ignore_errors=True)
+        raise
+
+    job = {
+        "id": job_id,
+        "status": "queued",
+        "progress": 10,
+        "stage": "Upload received",
+        "mode": selected_mode,
+        "model": selected_model,
+        "source": original_name,
+        "workDir": str(work_dir),
+        "createdAt": time.time(),
+        "updatedAt": time.time(),
+    }
+    with JOBS_LOCK:
+        JOBS[job_id] = job
+
+    thread = threading.Thread(
+        target=_process_job,
+        args=(job_id, input_path, work_dir, original_name, selected_model, selected_mode),
+        daemon=True,
+    )
+    thread.start()
+    return JSONResponse(_public_job(job))
+
+
+@app.get("/jobs/{job_id}")
+def get_job(job_id: str) -> JSONResponse:
+    with JOBS_LOCK:
+        job = JOBS.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    return JSONResponse(_public_job(job))
+
+
+@app.get("/jobs/{job_id}/download")
+def download_job(job_id: str) -> FileResponse:
+    with JOBS_LOCK:
+        job = JOBS.get(job_id)
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    if job.get("status") != "ready" or not job.get("zipPath"):
+        raise HTTPException(status_code=409, detail="Job is not ready")
+    zip_path = Path(job["zipPath"])
+    if not zip_path.exists():
+        raise HTTPException(status_code=404, detail="Stem ZIP was not found")
+    return FileResponse(
+        zip_path,
+        filename=f"neuralis-stems-{job_id}.zip",
+        media_type="application/zip",
+    )
+
+
 @app.post("/separate")
 async def separate(
     request: Request,
@@ -225,11 +480,7 @@ async def separate(
     mode: str = Form(DEFAULT_MODE),
     apiKey: str = Form(""),
 ) -> FileResponse:
-    expected = os.getenv("NEURALIS_STEM_API_KEY", "").strip()
-    if expected and not _client_key(request) and apiKey.strip() != expected:
-        raise HTTPException(status_code=401, detail="Invalid Neuralis stem API key")
-    if expected and _client_key(request) and _client_key(request) != expected:
-        raise HTTPException(status_code=401, detail="Invalid Neuralis stem API key")
+    _check_api_key(request, apiKey)
 
     selected_model = (model or DEFAULT_MODEL).strip()
     if selected_model not in ALLOWED_MODELS: