Spaces:
Paused
Paused
Download app/server.py from 2Btainment/absolution-omega: direct link, hf CLI and curl.
- Browser
- Download file 70 kB
-
https://huggingface.co/spaces/2Btainment/absolution-omega/resolve/main/app/server.py
- Command line
-
hf download hf://spaces/2Btainment/absolution-omega/app/server.py
-
curl -L -o server.py https://huggingface.co/spaces/2Btainment/absolution-omega/resolve/main/app/server.py
70 kB
"""Local-first FastAPI server for Tune-Whisperer (internal: ABSOLUTION Ω) v1.1.
No remote calls are made by this application. Jobs are process-local and not
durable; no public multi-user deployment without authorization is supported.
"""
from __future__ import annotations
import json
import importlib.util
import os
import threading
import uuid
import zipfile
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
from pathlib import Path
from typing import Literal
import numpy as np
import soundfile as sf
from fastapi import FastAPI, File, Form, HTTPException, UploadFile
from fastapi.responses import FileResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel, Field
from .bass import BassParams, TRACKS, process_bass_file
from .noise import RepairParams, inspect_noise_file, repair_noise_file
from .virtualbass import available as virtualbass_available, render_virtualbass
from .mini_model import inspect_file as inspect_mini, MODEL_FILE
from .mixer import render_mix, sampled_peaks, rubberband_available
from .unified import build_unified_graph
from .omnistem import compile_plan, execute_plan
from . import access
import contextvars, secrets as _secrets
from http.cookies import SimpleCookie
from fastapi import Request
from fastapi.responses import RedirectResponse
from .audio import (
AudioError, align_and_resample, analyze_file, hpss_separate_file,
load_audio, mixture_report, save_stems, sha256_file,
)
# Byte quota protects local disk; no maximum duration is imposed on audio.
# Configure ABSOLUTION_MAX_UPLOAD_MIB to fit your available storage.
MAX_UPLOAD_MIB = max(1, min(4096, int(os.environ.get("ABSOLUTION_MAX_UPLOAD_MIB", "1024"))))
MAX_UPLOAD_BYTES = MAX_UPLOAD_MIB * 1024 * 1024
ALLOWED_EXTENSIONS = {".wav", ".flac", ".aif", ".aiff", ".mp3", ".ogg"}
def timestamp() -> str:
return datetime.now(timezone.utc).isoformat(timespec="seconds")
def check_id(raw: str) -> str:
try:
return str(uuid.UUID(raw))
except ValueError as exc:
raise HTTPException(status_code=404, detail="Project not found.") from exc
# Demucs on shared CPU hardware: cap input duration (0 = unlimited).
DEMUCS_MAX_SECONDS = float(os.environ.get("ABSOLUTION_DEMUCS_MAX_SECONDS", "0"))
class ProjectCreate(BaseModel):
name: str = Field(default="Untitled project", min_length=1, max_length=80)
class ProjectRename(BaseModel):
name: str = Field(min_length=1, max_length=80)
class FusionRequest(BaseModel):
project_id: str
mode: Literal["auto", "neural", "dsp"] = "auto"
include_event_proxies: bool = True
scan_noise: bool = True
class SeparationRequest(BaseModel):
project_id: str
model: Literal["hpss", "demucs"] = "hpss"
target_description: str = Field(default="", max_length=300)
class BassRequest(BaseModel):
project_id: str
source_mode: Literal["auto", "dsp", "hpss", "demucs"] = "auto"
crossover_hz: float = Field(default=220, ge=45, le=350)
kick_focus: float = Field(default=0.75, ge=0, le=1)
kick_gain_db: float = Field(default=0, ge=-12, le=12)
bass_gain_db: float = Field(default=0, ge=-12, le=12)
sub_gain_db: float = Field(default=0, ge=-12, le=12)
harmonics: float = Field(default=0.20, ge=0, le=1)
lowcut_hz: float = Field(default=22, ge=10, le=45)
mono_below_hz: float = Field(default=100, ge=0, le=180)
wet: float = Field(default=1, ge=0, le=1)
ceiling_dbfs: float = Field(default=-1, ge=-6, le=-0.1)
class NoiseScanRequest(BaseModel):
project_id: str
class NoiseRepairRequest(BaseModel):
project_id: str
approved_samples: list[int] = Field(default_factory=list, max_length=400)
strength: float = Field(default=0.8, ge=0, le=1)
class VirtualBassRequest(BaseModel):
project_id: str
cutoff_hz: float = Field(default=250, ge=100, le=500)
strength: float = Field(default=1.0, ge=0.5, le=3.0)
class TrackMix(BaseModel):
gain_db: float = Field(default=0, ge=-48, le=12)
pan: float = Field(default=0, ge=-1, le=1)
mute: bool = False
solo: bool = False
highpass_hz: float = Field(default=0, ge=0, le=400)
lowpass_hz: float = Field(default=0, ge=0, le=18000)
width: float = Field(default=1, ge=0, le=2)
drive: float = Field(default=0, ge=0, le=1)
delay_ms: float = Field(default=0, ge=0, le=280)
delay_mix: float = Field(default=0, ge=0, le=0.55)
room: float = Field(default=0, ge=0, le=0.45)
class MixerRequest(BaseModel):
project_id: str
tracks: dict[str, TrackMix] = Field(default_factory=dict)
tempo: float = Field(default=1, ge=0.5, le=2)
pitch_semitones: float = Field(default=0, ge=-12, le=12)
class PlannedTrack(BaseModel):
id: str = Field(min_length=1, max_length=60, pattern=r"^[a-z0-9_-]+$")
label: str = Field(min_length=1, max_length=100)
enabled: bool = True
class PlanRequest(BaseModel):
tracks: list[PlannedTrack] = Field(max_length=128)
class _ContextExecutor:
"""Runs jobs inside the submitting request's context so they keep its namespace."""
def __init__(self, inner):
self.inner = inner
def submit(self, fn, *args, **kwargs):
ctx = contextvars.copy_context()
return self.inner.submit(ctx.run, fn, *args, **kwargs)
class Service:
def __init__(self, data_root: Path):
self.base_root = data_root.resolve()
self.base_root.mkdir(parents=True, exist_ok=True)
self.lock = threading.RLock()
self.jobs: dict[str, dict] = {}
self.executor = _ContextExecutor(ThreadPoolExecutor(max_workers=2, thread_name_prefix="omega"))
self.model_repo = os.environ.get("ABSOLUTION_DEMUCS_REPO", "").strip()
@property
def data_root(self) -> Path:
"""Namespace root of the current request (owner root or guests/<ns>). Fails closed."""
root = access.current_root.get()
if root is None:
raise HTTPException(status_code=403, detail="No session namespace.")
return root
def folder(self, project_id: str) -> Path:
project_id = check_id(project_id)
folder = self.data_root / project_id
if not (folder / "manifest.json").is_file():
raise HTTPException(status_code=404, detail="Project not found.")
return folder
def manifest(self, project_id: str) -> dict:
return json.loads((self.folder(project_id) / "manifest.json").read_text(encoding="utf-8"))
def write_manifest(self, project_id: str, manifest: dict) -> None:
folder = self.data_root / check_id(project_id)
target = folder / "manifest.json"
temp = folder / f".{uuid.uuid4().hex}.tmp"
temp.write_text(json.dumps(manifest, indent=2, ensure_ascii=False), encoding="utf-8")
temp.replace(target)
def create_project(self, name: str) -> dict:
project_id = str(uuid.uuid4())
folder = self.data_root / project_id
folder.mkdir()
manifest = {
"id": project_id, "name": name, "created_at": timestamp(),
"asset": None, "analysis": None, "stems": {},
"separation": None, "report": None, "bass": None, "noise": None, "virtualbass": None,
"inventory": None, "plan": [], "mixer": None, "unified": None,
"omnistem": None, "omnistem_base": None, "fusion": None,
}
self.write_manifest(project_id, manifest)
return manifest
def active_tracks(self, manifest: dict) -> dict:
graph = manifest.get("unified")
if graph and graph.get("mix_consistent"):
return graph["stems"]
return manifest.get("stems") or {}
def refresh_unified(self, project_id: str) -> dict | None:
"""Called only from worker or explicit user action. Never overwrites source."""
manifest = self.manifest(project_id)
graph = build_unified_graph(self.folder(project_id), manifest)
with self.lock:
latest = self.manifest(project_id)
latest["unified"] = graph
latest["omnistem"] = None
latest["omnistem_base"] = None
latest["mixer"] = None
# Keep the provenance display in sync when a user later approves
# a click repair (which adds a genuine difference lane).
if latest.get("fusion"):
fusion = latest["fusion"]
current = graph["stems"] if graph and graph.get("mix_consistent") else latest.get("stems", {})
previous = fusion.get("stems") or {}
refreshed = {}
for name, item in current.items():
meta = previous.get(name, {})
parent = (
"Manuell freigegebene Klick-Reparatur des Originals"
if name == "noise_difference" else
"HPSS Percussive-Stem" if name == "kick_core" and fusion["method"] == "hpss" else
"HPSS Harmonic-Stem" if name == "bassline_core" and fusion["method"] == "hpss" else
"Demucs Drums-Stem" if name == "kick_core" else
"Demucs Bass-Stem" if name == "bassline_core" else
meta.get("derived_from", "Originalmix / bisherige Separation")
)
refreshed[name] = {
"label": item.get("label", name),
"role": item.get("role", name),
"derived_from": parent,
"type": (
"approved_repair" if name == "noise_difference" else
"dsp_estimate" if name in ("kick_core", "bassline_core", "snare_proxy", "hat_proxy") else
"neural" if fusion["method"] == "demucs" and name in ("vocals", "drums", "bass", "other") else
"signal_component"
),
}
fusion["stems"] = refreshed
fusion["mixture_consistent"] = bool(graph and graph.get("mix_consistent"))
fusion["noise_candidates"] = len(
((latest.get("noise") or {}).get("scan") or {}).get("events") or []
)
fusion["warnings"] = [
note for note in fusion.get("warnings", [])
if not ("Störspur" in note)
] if "noise_difference" in refreshed else fusion.get("warnings", [])
fusion["updated_at"] = timestamp()
self.write_manifest(project_id, latest)
return graph
def create_omnistem_job(self, project_id: str) -> dict:
project_id = check_id(project_id)
with self.lock:
manifest = self.manifest(project_id)
if not manifest.get("asset"):
raise HTTPException(status_code=409, detail="Bitte Audio importieren.")
if not manifest.get("stems"):
raise HTTPException(status_code=409, detail="Zuerst HPSS oder Demucs separieren.")
if any(j["project_id"] == project_id and j["status"] in ("queued","running")
for j in self.jobs.values()):
raise HTTPException(status_code=409, detail="Projekt wird bereits verarbeitet.")
job = {"id": str(uuid.uuid4()), "project_id": project_id,
"kind": "omnistem", "model": "explicit_plan_dsp_proxy_v1",
"status": "queued", "progress": 0,
"created_at": timestamp(), "error": None}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]] = job
self.executor.submit(self.run_omnistem_job, job["id"])
return {k: v for k, v in job.items() if k != "ns_root"}
def run_omnistem_job(self, job_id: str) -> None:
pid = self.jobs[job_id]["project_id"]
try:
self.update_job(job_id, status="running", progress=5)
manifest = self.manifest(pid)
source_graph = manifest.get("unified")
if source_graph and source_graph.get("mode") == "omnistem_plan_v1":
source_graph = manifest.get("omnistem_base")
newgraph, report = execute_plan(
self.folder(pid), manifest, manifest.get("plan") or [],
progress=lambda f: self.update_job(job_id, progress=5+int(90*f)),
)
with self.lock:
updated = self.manifest(pid)
updated["omnistem_base"] = source_graph
updated["omnistem"] = {
"id": job_id, "completed_at": timestamp(),
"source_sha256": updated["asset"]["sha256"], "compiled": report,
"note": "No neural instrument isolation. Proxies are estimates.",
}
updated["unified"] = newgraph
updated["mixer"] = None
self.write_manifest(pid, updated)
self.update_job(job_id, status="done", progress=100)
except Exception as exc:
self.update_job(job_id, status="failed", error=f"{type(exc).__name__}: {exc}")
def create_fusion_job(self, request: FusionRequest) -> dict:
"""Single user operation; each internal stage is sequential and real."""
pid = check_id(request.project_id)
with self.lock:
manifest = self.manifest(pid)
if not manifest.get("asset"):
raise HTTPException(status_code=409, detail="Zuerst eine Audiodatei importieren.")
if any(j["project_id"] == pid and j["status"] in ("queued", "running")
for j in self.jobs.values()):
raise HTTPException(status_code=409, detail="Projekt wird gerade verarbeitet.")
neural_available = self.model_info()[1]["ready"]
if request.mode == "neural" and not neural_available:
raise HTTPException(
status_code=409,
detail="Echte Vocals-/Bass-/Drums-KI braucht lokale Demucs-Gewichte."
)
resolved = "demucs" if neural_available and request.mode != "dsp" else "hpss"
fallback_note = None
if resolved == "demucs" and DEMUCS_MAX_SECONDS > 0:
duration = float((manifest.get("analysis") or {}).get("duration_seconds") or 0)
if duration > DEMUCS_MAX_SECONDS:
if request.mode == "neural":
raise HTTPException(status_code=413, detail=(
f"Demucs ist auf dieser CPU-Instanz auf {DEMUCS_MAX_SECONDS:g} s begrenzt "
f"(Datei: {duration:.0f} s). Bitte DSP-Modus wählen oder lokal arbeiten."))
resolved = "hpss"
fallback_note = (f"Demucs übersprungen: Datei {duration:.0f} s > {DEMUCS_MAX_SECONDS:g} s Limit "
"dieser Instanz; HPSS verwendet.")
job = {
"id": str(uuid.uuid4()), "project_id": pid, "kind": "fusion",
"model": resolved, "status": "queued", "progress": 0,
"stage": "Warte auf Verarbeitung", "created_at": timestamp(),
"error": None,
}
if fallback_note:
job["fallback_note"] = fallback_note
job["ns_root"] = str(self.data_root); self.jobs[job["id"]] = job
self.executor.submit(self.run_fusion_job, job["id"], request.model_dump())
return {k: v for k, v in job.items() if k != "ns_root"}
def _fusion_stage(self, parent_id: str, stage: str, progress: int,
method, *args) -> None:
"""Execute an existing validated worker in the SAME processing task.
No parallel processing, no second input, no hidden gain changes.
"""
pid = self.jobs[parent_id]["project_id"]
child = str(uuid.uuid4())
self.jobs[child] = {
"id": child, "project_id": pid, "kind": "fusion_internal",
"model": self.jobs[parent_id]["model"], "status": "running", "progress": 0, "error": None,
}
self.update_job(parent_id, progress=progress, stage=stage)
try:
method(child, *args)
result = self.jobs[child]
if result["status"] != "done":
raise RuntimeError(result.get("error") or stage + " fehlgeschlagen")
finally:
# Internal implementation details are not independent user jobs.
with self.lock:
self.jobs.pop(child, None)
def run_fusion_job(self, job_id: str, options: dict) -> None:
pid = self.jobs[job_id]["project_id"]
method = self.jobs[job_id]["model"]
warnings: list[str] = []
if self.jobs[job_id].get("fallback_note"):
warnings.append(self.jobs[job_id]["fallback_note"])
stages: list[str] = []
try:
self.update_job(job_id, status="running", progress=2, stage="Klanginventur")
manifest = self.manifest(pid)
source = self.folder(pid) / manifest["asset"]["stored_name"]
# Inventory is a prior hypothesis, not proof of separated sources.
try:
inventory = inspect_mini(source)
selected = [
{"id": item["id"], "label": item["label"], "enabled": True}
for item in inventory.get("detections", [])
if item.get("suggested", False)
]
with self.lock:
updated = self.manifest(pid)
updated["inventory"] = inventory
if not updated.get("plan"):
updated["plan"] = selected
self.write_manifest(pid, updated)
stages.append("Lokale KI-Klanginventur (Hypothesen)")
except (ValueError, FileNotFoundError) as exc:
warnings.append("Mini-KI nicht verfügbar: " + str(exc))
self._fusion_stage(job_id, "Grundquellen separieren", 12, self.run_job)
stages.append("Demucs Vier-Stem-Separation" if method == "demucs"
else "HPSS Harmonik/Percussion (DSP)")
# Bass extraction reads exactly these separation outputs; not a new
# analysis of a mysterious input or extra copy of the original.
bass_mode = "demucs" if method == "demucs" else "hpss"
neutral_bass = BassRequest(
project_id=pid, source_mode=bass_mode, wet=0, harmonics=0,
kick_gain_db=0, bass_gain_db=0, sub_gain_db=0,
)
self.jobs[job_id]["bass_source"] = (
"Demucs: bass + drums" if method == "demucs"
else "HPSS: harmonic + percussive"
)
# Existing run_bass_job reads mode from child job metadata.
child_id = str(uuid.uuid4())
with self.lock:
self.jobs[child_id] = {
"id": child_id, "project_id": pid, "kind": "fusion_internal",
"mode": bass_mode, "status": "running", "progress": 0, "error": None,
}
self.update_job(job_id, progress=43, stage="Kick und Bassline ableiten")
try:
self.run_bass_job(child_id, neutral_bass)
if self.jobs[child_id]["status"] != "done":
raise RuntimeError(self.jobs[child_id].get("error") or "Bass fehlgeschlagen")
finally:
with self.lock:
self.jobs.pop(child_id, None)
stages.append("Kick/Bassline als kompensierte DSP-Schätzspuren")
if options.get("scan_noise", True):
current = self.manifest(pid)
old = current.get("noise") or {}
if old.get("scan") and old.get("source_sha256") == current["asset"]["sha256"]:
stages.append("Vorhandenen Störstellen-Scan behalten")
else:
self._fusion_stage(job_id, "Störstellen erkennen (ohne Entfernung)", 68,
self.run_noise_job, "scan", [], 0.8)
stages.append("NOISE-CORE: Klickverdacht nur markiert")
current = self.manifest(pid)
if options.get("include_event_proxies", True) and current.get("plan"):
self._fusion_stage(job_id, "Planfähigkeiten und Elemente prüfen", 83,
self.run_omnistem_job)
stages.append("OMNISTEM: nur verfügbare DSP-Proxies / vorhandene Stems")
final = self.manifest(pid)
active = self.active_tracks(final)
lineage = {}
parents = {
"kick_core": "Demucs Drums-Stem" if method == "demucs" else "HPSS Percussive-Stem",
"bassline_core": "Demucs Bass-Stem" if method == "demucs" else "HPSS Harmonic-Stem",
"noise_difference": "Manuell freigegebene Reparatur des Originalsignals",
"snare_proxy": "Drums-Stem · Mittenimpuls-Proxy" if method == "demucs" else "Percussive-Stem · Mittenimpuls-Proxy",
"hat_proxy": "Drums-Stem · Höhenimpuls-Proxy" if method == "demucs" else "Percussive-Stem · Höhenimpuls-Proxy",
}
for name, info in active.items():
lineage[name] = {
"label": info.get("label", name),
"role": info.get("role", name),
"derived_from": parents.get(name) or info.get("derived_from") or (
"Originalmix → Demucs KI-Separation" if method == "demucs"
else "Originalmix → HPSS-DSP-Separation"
),
"type": (
"neural" if method == "demucs" and name in ("vocals", "drums", "other", "bass")
else "dsp_estimate" if name in ("kick_core", "bassline_core", "snare_proxy", "hat_proxy")
else "approved_repair" if name == "noise_difference"
else "signal_component"
),
}
missing = []
if method != "demucs":
missing.append("Vocals sind NICHT isoliert: lokales Demucs-Modell fehlt oder DSP-Modus gewählt.")
if not (final.get("noise") or {}).get("repair"):
missing.append("Störspur ist noch nicht erzeugt: erkannte Klicks erst manuell freigeben.")
fusion = {
"id": job_id, "name": "Ω FUSION", "completed_at": timestamp(),
"source_sha256": final["asset"]["sha256"],
"method": method, "mode_requested": options["mode"],
"bass_parent": (
{"kick": "drums", "bassline": "bass"} if method == "demucs"
else {"kick": "percussive", "bassline": "harmonic"}
),
"stages": stages, "stems": lineage, "warnings": warnings + missing,
"noise_candidates": len(((final.get("noise") or {}).get("scan") or {}).get("events") or []),
"noise_removal_automatic": False,
"mixture_consistent": bool((final.get("unified") or {}).get("mix_consistent")),
}
with self.lock:
newest = self.manifest(pid)
newest["fusion"] = fusion
self.write_manifest(pid, newest)
self.update_job(job_id, progress=100, status="done",
stage=f"Fertig: {len(lineage)} tatsächlich vorhandene Audiospuren")
except Exception as exc:
self.update_job(job_id, status="failed", stage="Angehalten",
error=f"{type(exc).__name__}: {exc}")
def create_unified_job(self, project_id: str) -> dict:
project_id = check_id(project_id)
with self.lock:
manifest = self.manifest(project_id)
if not manifest.get("asset"):
raise HTTPException(status_code=409, detail="Import audio before building tracks.")
if any(j["project_id"]==project_id and j["status"] in ("queued","running")
for j in self.jobs.values()):
raise HTTPException(status_code=409, detail="Project already processing.")
job={"id":str(uuid.uuid4()),"project_id":project_id,
"kind":"unified", "model":"canonical_track_graph",
"status":"queued","progress":0,"created_at":timestamp(),"error":None}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]]=job
self.executor.submit(self.run_unified_job,job["id"])
return {k: v for k, v in job.items() if k != "ns_root"}
def run_unified_job(self, job_id: str):
pid=self.jobs[job_id]["project_id"]
try:
self.update_job(job_id,status="running",progress=10)
self.refresh_unified(pid)
self.update_job(job_id,status="done",progress=100)
except Exception as exc:
self.update_job(job_id,status="failed",error=f"{type(exc).__name__}: {exc}")
def create_mixer_job(self, request: MixerRequest) -> dict:
project_id=check_id(request.project_id)
with self.lock:
manifest=self.manifest(project_id)
tracks = self.active_tracks(manifest)
if not tracks:
raise HTTPException(status_code=409,detail="Run separation or build BASS/NOISE tracks first.")
unknown=set(request.tracks)-set(tracks)
if unknown:
raise HTTPException(status_code=422,detail="Unknown real stems: "+", ".join(sorted(unknown)))
if len(tracks)>128:
raise HTTPException(status_code=422,detail="More than 128 stems not supported for one render.")
if (request.tempo!=1 or request.pitch_semitones!=0) and not rubberband_available():
raise HTTPException(status_code=422,detail="FFmpeg with rubberband is required for independent tempo/pitch.")
if any(j["project_id"]==project_id and j["status"] in ("queued","running")
for j in self.jobs.values()):
raise HTTPException(status_code=409,detail="Project already processing.")
job={"id":str(uuid.uuid4()),"project_id":project_id,
"model":"arrangement_mixer","kind":"mix","status":"queued",
"progress":0,"created_at":timestamp(),"error":None}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]]=job
self.executor.submit(self.run_mixer_job,job["id"],request.model_dump())
return {k: v for k, v in job.items() if k != "ns_root"}
def run_mixer_job(self, job_id: str, settings:dict):
job=self.jobs[job_id];project_id=job["project_id"]
try:
self.update_job(job_id,status="running",progress=3)
manifest=self.manifest(project_id);folder=self.folder(project_id)
graph = manifest.get("unified")
if graph and graph.get("mix_consistent"):
sources={name:folder/data["master"] for name,data in graph["stems"].items()}
else:
sources={name:folder/"stems"/data["master"] for name,data in manifest["stems"].items()}
output=folder/"mixer"/(job_id+".wav")
result=render_mix(sources,settings,output,
progress=lambda r:self.update_job(job_id,progress=3+int(r*90)))
with self.lock:
newest=self.manifest(project_id)
newest["mixer"]={"id":job_id,"file":output.name,"settings":settings,
"result":result,"created_at":timestamp()}
self.write_manifest(project_id,newest)
self.update_job(job_id,status="done",progress=100)
except Exception as exc:
self.update_job(job_id,status="failed",error=f"{type(exc).__name__}: {exc}")
def model_info(self) -> list[dict]:
local = Path(self.model_repo).expanduser() if self.model_repo else None
configured = bool(local and local.is_dir() and
any(local.rglob("*.th")))
runtime_ready = (importlib.util.find_spec("demucs") is not None
and importlib.util.find_spec("torch") is not None)
return [
{
"id": "hpss", "name": "HPSS · deterministic DSP",
"ready": True, "type": "signal_processing",
"stems": ["harmonic", "percussive", "residual"],
"limitations": "Not neural, not instrument-/vocal-specific.",
},
{
"id": "demucs", "name": "Demucs HT v4 · neural (local weights)",
"ready": configured and runtime_ready, "type": "neural_network",
"checkpoint_configured": configured, "runtime_ready": runtime_ready,
"stems": ["drums", "bass", "other", "vocals", "residual"],
"limitations": ("Requires trusted local htdemucs weights/config (official checkpoint 955717e8) and optional "
"demucs/torch dependencies. No automatic downloads."),
},
]
def create_job(self, request: SeparationRequest) -> dict:
project_id = check_id(request.project_id)
with self.lock:
manifest = self.manifest(project_id)
if not manifest["asset"]:
raise HTTPException(status_code=409, detail="Import audio before separation.")
if request.model == "demucs" and not self.model_info()[1]["ready"]:
raise HTTPException(status_code=409, detail="Demucs not configured; local checkpoints required.")
if request.model == "demucs" and DEMUCS_MAX_SECONDS > 0:
duration = float((manifest.get("analysis") or {}).get("duration_seconds") or 0)
if duration > DEMUCS_MAX_SECONDS:
raise HTTPException(status_code=413, detail=(
f"Demucs on this CPU instance is limited to {DEMUCS_MAX_SECONDS:g} s audio "
f"(file: {duration:.0f} s). Use HPSS or run locally."))
if request.target_description.strip() and request.model == "hpss":
raise HTTPException(status_code=422, detail="HPSS cannot follow arbitrary text prompts.")
# Explicitly reject the unsupported "text conditioned" interpretation for neural.
if request.target_description.strip() and request.model == "demucs":
raise HTTPException(status_code=422, detail="Demucs v4 here offers fixed 4 stems, not text prompting.")
if any(job["project_id"] == project_id and job["status"] in ("queued", "running")
for job in self.jobs.values()):
raise HTTPException(status_code=409, detail="A project job is already running.")
job = {
"id": str(uuid.uuid4()), "project_id": project_id, "model": request.model,
"status": "queued", "progress": 0, "created_at": timestamp(), "error": None,
}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]] = job
self.executor.submit(self.run_job, job["id"])
return {k: v for k, v in job.items() if k != "ns_root"}
def create_bass_job(self, request: BassRequest) -> dict:
project_id = check_id(request.project_id)
with self.lock:
manifest = self.manifest(project_id)
if not manifest["asset"]:
raise HTTPException(status_code=409, detail="Import audio before BASS-CORE.")
active = any(j["project_id"] == project_id and j["status"] in ("queued", "running")
for j in self.jobs.values())
if active:
raise HTTPException(status_code=409, detail="A project job is already running.")
stems = manifest.get("stems") or {}
separation = (manifest.get("separation") or {}).get("method")
valid_hpss = separation == "hpss" and all(k in stems for k in ("harmonic","percussive"))
valid_neural = separation == "demucs" and all(k in stems for k in ("bass","drums"))
mode = request.source_mode
if mode == "auto":
mode = "demucs" if valid_neural else "hpss" if valid_hpss else "dsp"
if mode == "hpss" and not valid_hpss:
raise HTTPException(status_code=409, detail="Run HPSS separation first.")
if mode == "demucs" and not valid_neural:
raise HTTPException(status_code=409, detail="Run Demucs bass/drums separation first.")
job = {
"id": str(uuid.uuid4()), "project_id": project_id, "model": "basscore",
"mode": mode, "kind": "bass", "status": "queued", "progress": 0,
"created_at": timestamp(), "error": None,
}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]] = job
self.executor.submit(self.run_bass_job, job["id"], request)
return {k: v for k, v in job.items() if k != "ns_root"}
def run_bass_job(self, job_id: str, request: BassRequest) -> None:
job = self.jobs[job_id]
project_id, mode = job["project_id"], job["mode"]
try:
self.update_job(job_id, status="running", progress=5)
manifest = self.manifest(project_id)
folder = self.folder(project_id)
refs = {}
wanted = {"dsp": (), "hpss": ("harmonic","percussive"),
"demucs": ("bass","drums")}[mode]
for name in wanted:
refs[name] = folder / "stems" / manifest["stems"][name]["master"]
settings = BassParams(**request.model_dump(exclude={"project_id","source_mode"}))
out = folder / "basscore" / job_id
stems, report = process_bass_file(
folder / manifest["asset"]["stored_name"], out, settings,
mode=mode, refs=refs,
progress=lambda ratio:self.update_job(job_id, progress=5 + int(90 * ratio)),
)
result = {"id": job_id, "completed_at": timestamp(), "mode": mode,
"source_sha256": manifest["asset"]["sha256"],
"stems": stems, "report": report}
with self.lock:
updated = self.manifest(project_id)
updated["bass"] = result
updated["unified"] = None
self.write_manifest(project_id, updated)
self.update_job(job_id, progress=94)
self.refresh_unified(project_id)
self.update_job(job_id, status="done", progress=100)
except Exception as exc:
self.update_job(job_id, status="failed", error=f"{type(exc).__name__}: {exc}")
def create_noise_job(self, project_id: str, action: str,
approved: list[int] | None=None, strength: float=0.8) -> dict:
project_id=check_id(project_id)
with self.lock:
manifest=self.manifest(project_id)
if not manifest.get("asset"):
raise HTTPException(status_code=409,detail="Import audio before NOISE-CORE.")
if any(j["project_id"]==project_id and j["status"] in ("queued","running")
for j in self.jobs.values()):
raise HTTPException(status_code=409,detail="A project job is already running.")
if action=="repair":
scan=(manifest.get("noise") or {}).get("scan")
if not scan:
raise HTTPException(status_code=409,detail="Scan for click hypotheses first.")
allowed={event["sample"] for event in scan["events"]}
if not set(approved or []).issubset(allowed):
raise HTTPException(status_code=422,detail="Repair only confirmed scan events.")
if not approved:
raise HTTPException(status_code=422,detail="Select at least one click candidate.")
job={
"id":str(uuid.uuid4()),"project_id":project_id,
"model":"noisecore","kind":"noise_"+action,
"status":"queued","progress":0,"created_at":timestamp(),"error":None,
}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]]=job
self.executor.submit(self.run_noise_job,job["id"],action,approved or [],strength)
return {k: v for k, v in job.items() if k != "ns_root"}
def run_noise_job(self, job_id:str, action:str, approved:list[int], strength:float)->None:
project_id=self.jobs[job_id]["project_id"]
try:
self.update_job(job_id,status="running",progress=3)
manifest=self.manifest(project_id)
folder=self.folder(project_id)
source=folder/manifest["asset"]["stored_name"]
callback=lambda ratio:self.update_job(job_id,progress=5+int(90*ratio))
if action=="scan":
scan=inspect_noise_file(source,progress=callback)
with self.lock:
updated=self.manifest(project_id)
# Old repair, if any, must not be attached to a new scan.
updated["noise"]={"scan":scan,"repair":None,
"source_sha256":manifest["asset"]["sha256"],
"scanned_at":timestamp()}
self.write_manifest(project_id,updated)
else:
root=folder/"noisecore"/job_id
tracks,report=repair_noise_file(
source,root,approved,RepairParams(strength),progress=callback)
with self.lock:
updated=self.manifest(project_id)
updated["noise"]["repair"]={
"id":job_id,"completed_at":timestamp(),
"source_sha256":manifest["asset"]["sha256"],
"tracks":tracks,"report":report,
}
self.write_manifest(project_id,updated)
self.update_job(job_id,progress=94)
self.refresh_unified(project_id)
self.update_job(job_id,status="done",progress=100)
except Exception as exc:
self.update_job(job_id,status="failed",error=f"{type(exc).__name__}: {exc}")
def create_virtualbass_job(self, request: VirtualBassRequest) -> dict:
pid=check_id(request.project_id)
with self.lock:
manifest=self.manifest(pid)
if not manifest.get("asset"):
raise HTTPException(status_code=409,detail="Import stereo audio first.")
if not virtualbass_available():
raise HTTPException(status_code=409,detail="FFmpeg virtualbass filter not available locally.")
if manifest["analysis"]["channels"]!=2:
raise HTTPException(status_code=422,detail="Virtualbass requires two-channel stereo.")
if any(j["project_id"]==pid and j["status"] in ("queued","running")
for j in self.jobs.values()):
raise HTTPException(status_code=409,detail="Project has a running job.")
job={"id":str(uuid.uuid4()),"project_id":pid,"model":"ffmpeg_virtualbass",
"kind":"virtualbass","status":"queued","progress":0,
"created_at":timestamp(),"error":None}
job["ns_root"] = str(self.data_root); self.jobs[job["id"]]=job
self.executor.submit(self.run_virtualbass_job,job["id"],request)
return {k: v for k, v in job.items() if k != "ns_root"}
def run_virtualbass_job(self, job_id:str, request:VirtualBassRequest) -> None:
job=self.jobs[job_id]
pid=job["project_id"]
try:
self.update_job(job_id,status="running",progress=10)
manifest=self.manifest(pid)
folder=self.folder(pid)
target=folder/"virtualbass"/job_id/"virtualbass_2_1.wav"
report=render_virtualbass(
folder/manifest["asset"]["stored_name"],target,
cutoff_hz=request.cutoff_hz,strength=request.strength
)
self.update_job(job_id,progress=95)
with self.lock:
updated=self.manifest(pid)
updated["virtualbass"]={
"id":job_id,"source_sha256":manifest["asset"]["sha256"],
"completed_at":timestamp(),"report":report,
}
self.write_manifest(pid,updated)
self.update_job(job_id,status="done",progress=100)
except Exception as exc:
self.update_job(job_id,status="failed",error=f"{type(exc).__name__}: {exc}")
def update_job(self, job_id: str, **kwargs) -> None:
with self.lock:
self.jobs[job_id].update(kwargs)
def run_job(self, job_id: str) -> None:
job = self.jobs[job_id]
project_id, model = job["project_id"], job["model"]
try:
self.update_job(job_id, status="running", progress=8)
manifest = self.manifest(project_id)
folder = self.folder(project_id)
input_path = folder / manifest["asset"]["stored_name"]
self.update_job(job_id, progress=20)
if model == "hpss":
# Bounded-memory streaming path for long recordings.
stem_info, report = hpss_separate_file(
input_path, folder / "stems",
progress=lambda fraction: self.update_job(
job_id, progress=20 + int(70 * fraction)
),
)
else:
# Optional neural adapter still depends on available RAM/VRAM.
original = load_audio(input_path)
stems = self.run_demucs(original)
self.update_job(job_id, progress=75)
report = mixture_report(original.samples, stems)
stem_info = save_stems(folder / "stems", original, stems)
self.update_job(job_id, progress=95)
with self.lock:
updated = self.manifest(project_id)
updated["stems"] = stem_info
updated["separation"] = {
"method": model, "completed_at": timestamp(),
"architecture": "median_filter_STFT_chunked_v2" if model == "hpss" else "htdemucs_v4",
"ai": model == "demucs", "source_sha256": manifest["asset"]["sha256"],
"master_format": "WAV 32-bit float",
"preview_format": "WAV PCM 16-bit (separate listening copies)",
}
updated["report"] = report
# Bass estimates tied to a prior separation must not survive re-separation.
if updated.get("bass") and updated["bass"].get("mode") in ("hpss", "demucs"):
updated["bass"] = None
updated["unified"] = None
updated["omnistem"] = None
updated["omnistem_base"] = None
updated["mixer"] = None
self.write_manifest(project_id, updated)
self.refresh_unified(project_id)
self.update_job(job_id, status="done", progress=100)
except Exception as exc:
self.update_job(job_id, status="failed", error=f"{type(exc).__name__}: {exc}")
def run_demucs(self, original):
"""Only runs with explicitly supplied trusted local checkpoints.
Demucs is optional; checkpoint loading may deserialize pickle. Don't point
this at untrusted downloaded weights. Never triggers a network fetch.
"""
if not self.model_repo:
raise AudioError("Demucs local repository not configured.")
from demucs.api import Separator # optional dependency
import torch
separator = Separator(
model="htdemucs", repo=Path(self.model_repo).expanduser(),
device="cuda" if torch.cuda.is_available() else "cpu",
shifts=0, overlap=0.25, split=True,
)
signal = torch.from_numpy(original.samples.T.astype(np.float32))
with torch.inference_mode():
_mix, sources = separator.separate_tensor(signal, sr=original.samplerate)
stems = {}
for name, value in sources.items():
array = value.detach().cpu().numpy().T
stems[name] = align_and_resample(
array, separator.samplerate, original.samplerate, len(original.samples)
)
accum = np.zeros_like(original.samples)
for value in stems.values():
accum += value
stems["residual"] = original.samples - accum
return stems
def writable_dir(preferred: Path, fallback: Path) -> Path:
"""Use the persistent mount (e.g. HF bucket at /data) if writable, else fallback."""
try:
preferred.mkdir(parents=True, exist_ok=True)
probe = preferred / f".probe-{uuid.uuid4().hex}"
probe.write_text("ok"); probe.unlink()
return preferred
except OSError:
fallback.mkdir(parents=True, exist_ok=True)
return fallback
def create_app(data_root: Path | None = None) -> FastAPI:
default = Path(os.environ.get("ABSOLUTION_DATA_DIR", "./omega_data"))
if data_root is None:
data_root = writable_dir(default, Path(os.environ.get("ABSOLUTION_FALLBACK_DIR", "/tmp/omega_data")))
service = Service(data_root)
sessions = access.Sessions(service.base_root)
sessions.start_cleanup_thread()
app = FastAPI(title="Tune-Whisperer", version="1.1.0",
description="Local-first audio forensic vertical slice")
app.state.service = service
static_dir = Path(__file__).parent / "static"
app.mount("/static", StaticFiles(directory=static_dir), name="static")
def _cookie_secure(scope) -> bool:
headers = dict(scope.get("headers") or [])
proto = headers.get(b"x-forwarded-proto", b"").decode() or scope.get("scheme", "http")
return proto == "https"
class SessionMiddleware:
def __init__(self, inner):
self.inner = inner
async def __call__(self, scope, receive, send):
if scope["type"] != "http":
return await self.inner(scope, receive, send)
raw = dict(scope.get("headers") or []).get(b"cookie", b"").decode("latin-1")
jar = SimpleCookie();
try: jar.load(raw)
except Exception: pass
session = sessions.verify(jar[access.COOKIE].value if access.COOKIE in jar else None)
fresh = session is None
if fresh:
session = sessions.new_anonymous()
ns, root = sessions.namespace(session)
scope.setdefault("state", {})
scope["state"]["omega_session"] = session
t1 = access.current_root.set(root)
t2 = access.current_identity.set({"ns": ns, "session": session})
async def send_wrapper(message):
if message["type"] == "http.response.start" and fresh:
hdrs = list(message.get("headers") or [])
hdrs.append((b"set-cookie", _session_cookie(sessions.sign(session), _cookie_secure(scope)).encode()))
message["headers"] = hdrs
await send(message)
try:
await self.inner(scope, receive, send_wrapper)
finally:
access.current_root.reset(t1); access.current_identity.reset(t2)
def _session_cookie(value: str, secure: bool) -> str:
attrs = f"{access.COOKIE}={value}; Path=/; Max-Age={access.SESSION_MAX_AGE}; HttpOnly"
return attrs + ("; Secure; SameSite=None" if secure else "; SameSite=Lax")
app.add_middleware(SessionMiddleware)
@app.get("/api/v1/me")
def me():
ident = access.current_identity.get() or {}
sess = ident.get("session") or {}
return {"owner": access.Sessions.is_owner(sess), "user": sess.get("user"),
"signed_in": sess.get("kind") == "hf", "namespace": "owner" if ident.get("ns") == "owner" else "guest",
"guest_ttl_hours": access.GUEST_TTL_SECONDS / 3600,
"oauth_available": access.oauth_config() is not None}
@app.get("/login")
def login(request: Request):
cfg = access.oauth_config()
if not cfg:
raise HTTPException(status_code=503, detail="HF OAuth not configured for this Space.")
state = _secrets.token_urlsafe(24)
resp = RedirectResponse(access.authorize_url(cfg, access.redirect_uri(cfg, str(request.base_url)), state), status_code=302)
resp.set_cookie("omega_oauth_state", state, max_age=600, httponly=True,
secure=_cookie_secure(request.scope), samesite="none" if _cookie_secure(request.scope) else "lax")
return resp
@app.get("/login/callback")
def login_callback(request: Request, code: str = "", state: str = ""):
cfg = access.oauth_config()
if not cfg:
raise HTTPException(status_code=503, detail="HF OAuth not configured.")
expected = request.cookies.get("omega_oauth_state")
if not code or not state or not expected or not _secrets.compare_digest(state, expected):
raise HTTPException(status_code=400, detail="Invalid OAuth state.")
try:
redirect = access.redirect_uri(cfg, str(request.base_url))
username = access.fetch_username(cfg, access.exchange_code(cfg, code, redirect))
except Exception as exc:
raise HTTPException(status_code=502, detail=f"OAuth failed: {type(exc).__name__}") from exc
session = sessions.for_user(username, request.scope.get("state", {}).get("omega_session"))
resp = RedirectResponse("/", status_code=302)
resp.headers.append("set-cookie", _session_cookie(sessions.sign(session), _cookie_secure(request.scope)))
resp.delete_cookie("omega_oauth_state")
return resp
@app.get("/logout")
def logout(request: Request):
resp = RedirectResponse("/", status_code=302)
anon = sessions.new_anonymous()
resp.headers.append("set-cookie", _session_cookie(sessions.sign(anon), _cookie_secure(request.scope)))
return resp
@app.get("/")
def home():
return FileResponse(static_dir / "index.html", media_type="text/html")
@app.get("/api/v1/demo")
def demo_audio():
"""Serve a bundled, entirely synthetic WAV without contacting the network."""
sample = static_dir / "demo.wav"
if not sample.is_file():
raise HTTPException(status_code=404, detail="Demo audio not installed.")
return FileResponse(sample, media_type="audio/wav", filename="tune-whisperer_demo.wav")
@app.get("/api/v1/health")
def health():
return {"status": "ok", "app": "Tune-Whisperer", "version": "1.1.0", "fusion_pipeline": True, "omnistem_plan_runner": True, "unified_stem_graph": True, "arrangement_studio": True, "mini_tag_model_ready": MODEL_FILE.is_file(), "rubberband_ready": rubberband_available(), "basscore": True, "noisecore": True, "virtualbass_ready": virtualbass_available(), "job_backend": "process-local", "persistent_storage": str(service.base_root).startswith("/data"), "guest_isolation": True, "oauth_configured": access.oauth_config() is not None, "demucs_max_seconds": DEMUCS_MAX_SECONDS or None,
"network_downloads": False, "auth": "hf_oauth_owner_only_library",
"max_upload_bytes": MAX_UPLOAD_BYTES,
"duration_limit_seconds": None, "streaming_hpss": True}
@app.get("/api/v1/models")
def models():
return {"models": service.model_info()}
@app.post("/api/v1/projects", status_code=201)
def create_project(data: ProjectCreate):
return service.create_project(data.name)
@app.get("/api/v1/projects")
def list_projects():
"""Local library: one explicitly labelled source asset per project."""
items = []
with service.lock:
for folder in service.data_root.iterdir():
if not folder.is_dir() or not (folder / "manifest.json").is_file():
continue
try:
m = json.loads((folder / "manifest.json").read_text(encoding="utf-8"))
if folder.name != check_id(str(m.get("id", ""))):
continue
items.append({
"id": m["id"], "name": m.get("name", "Unbenannt"),
"created_at": m.get("created_at"),
"asset": m.get("asset"),
"analysis": m.get("analysis"),
"stem_count": len(service.active_tracks(m)),
})
except (ValueError, KeyError, TypeError, json.JSONDecodeError, HTTPException):
continue
items.sort(key=lambda x: x.get("created_at") or "", reverse=True)
return {"projects": items}
@app.patch("/api/v1/projects/{project_id}")
def rename_project(project_id: str, req: ProjectRename):
with service.lock:
m = service.manifest(project_id)
m["name"] = req.name.strip()
if not m["name"]:
raise HTTPException(status_code=422, detail="Projektname darf nicht leer sein.")
service.write_manifest(project_id, m)
return {"id": project_id, "name": m["name"]}
@app.get("/api/v1/projects/{project_id}")
def get_project(project_id: str):
return service.manifest(project_id)
@app.post("/api/v1/assets", status_code=201)
async def upload_asset(project_id: str = Form(...), file: UploadFile = File(...)):
project_id = check_id(project_id)
original_name = Path(file.filename or "").name[:120]
suffix = Path(original_name).suffix.lower()
if suffix not in ALLOWED_EXTENSIONS:
raise HTTPException(status_code=415, detail="Unsupported audio file extension.")
with service.lock:
manifest = service.manifest(project_id)
if manifest["asset"] is not None:
raise HTTPException(status_code=409, detail="One imported file per project in v0.1.")
if any(j["project_id"] == project_id and j["status"] in ("queued", "running")
for j in service.jobs.values()):
raise HTTPException(status_code=409, detail="Project is busy.")
stored_name = "source" + suffix
path = service.folder(project_id) / stored_name
written = 0
try:
with path.open("xb") as destination:
while True:
part = await file.read(1024 * 1024)
if not part:
break
written += len(part)
if written > MAX_UPLOAD_BYTES:
raise HTTPException(status_code=413, detail=f"Max upload size is {MAX_UPLOAD_MIB} MiB.")
destination.write(part)
stats = analyze_file(path, service.folder(project_id) / "original_preview.wav")
asset = {
"id": str(uuid.uuid4()), "filename": original_name,
"stored_name": stored_name, "sha256": sha256_file(path),
"size_bytes": written,
}
manifest["asset"], manifest["analysis"] = asset, stats
service.write_manifest(project_id, manifest)
return {"asset": asset, "analysis": stats, "project_id": project_id}
except (AudioError, ValueError) as exc:
path.unlink(missing_ok=True)
(service.folder(project_id) / "original_preview.wav").unlink(missing_ok=True)
raise HTTPException(status_code=422, detail=str(exc)) from exc
except Exception:
path.unlink(missing_ok=True)
raise
finally:
await file.close()
@app.post("/api/v1/jobs/fusion", status_code=202)
def start_fusion(request: FusionRequest):
return service.create_fusion_job(request)
@app.post("/api/v1/jobs/separate", status_code=202)
def start_separation(request: SeparationRequest):
return service.create_job(request)
@app.get("/api/v1/jobs/{job_id}")
def get_job(job_id: str):
try:
job = dict(service.jobs[str(uuid.UUID(job_id))])
except (ValueError, KeyError) as exc:
raise HTTPException(status_code=404, detail="Job not found.") from exc
if job.get("ns_root") != str(service.data_root):
raise HTTPException(status_code=404, detail="Job not found.")
job.pop("ns_root", None)
return job
@app.post("/api/v1/jobs/bass", status_code=202)
def bass_job(request: BassRequest):
return service.create_bass_job(request)
@app.get("/api/v1/projects/{project_id}/bass")
def bass_results(project_id: str):
result = service.manifest(project_id).get("bass")
return {"bass": result}
@app.get("/api/v1/projects/{project_id}/bass/audio/{track}")
def bass_audio(project_id: str, track: str, preview: bool = False):
manifest = service.manifest(project_id)
result = manifest.get("bass")
if not result or track not in TRACKS or track not in result["stems"]:
raise HTTPException(status_code=404, detail="Bass track not found.")
info = result["stems"][track]
key = "preview" if preview else "master"
path = service.folder(project_id) / "basscore" / result["id"] / info[key]
if not path.is_file():
raise HTTPException(status_code=404, detail="Bass track not found.")
return FileResponse(path, media_type="audio/wav", filename=path.name)
@app.get("/api/v1/projects/{project_id}/bass/export")
def bass_export(project_id: str):
manifest = service.manifest(project_id)
result = manifest.get("bass")
if not result:
raise HTTPException(status_code=409, detail="Run BASS-CORE before exporting.")
folder = service.folder(project_id)
root = folder / "basscore" / result["id"]
target = root / "BASS_CORE_EXPORT.zip"
tmp = root / f".{uuid.uuid4().hex}.zip"
with zipfile.ZipFile(tmp, "w", compression=zipfile.ZIP_STORED) as archive:
archive.writestr("bass_report.json", json.dumps(result,indent=2,ensure_ascii=False))
for name, entry in result["stems"].items():
archive.write(root / entry["master"], f"stems/{entry['master']}")
tmp.replace(target)
return FileResponse(target,media_type="application/zip",filename="ABSOLUTION_BASS_CORE.zip")
@app.post("/api/v1/jobs/noise/scan",status_code=202)
def noise_scan(request:NoiseScanRequest):
return service.create_noise_job(request.project_id,"scan")
@app.post("/api/v1/jobs/noise/repair",status_code=202)
def noise_repair(request:NoiseRepairRequest):
return service.create_noise_job(request.project_id,"repair",
request.approved_samples,request.strength)
@app.get("/api/v1/projects/{project_id}/noise")
def noise_results(project_id:str):
return {"noise":service.manifest(project_id).get("noise")}
@app.get("/api/v1/projects/{project_id}/noise/audio/{track}")
def noise_audio(project_id:str, track:str, preview:bool=False):
result=(service.manifest(project_id).get("noise") or {}).get("repair")
if not result or track not in ("clean","difference"):
raise HTTPException(status_code=404,detail="NOISE-CORE track not found.")
item=result["tracks"][track]
path=service.folder(project_id)/"noisecore"/result["id"]/item[
"preview" if preview else "master"]
if not path.is_file():
raise HTTPException(status_code=404,detail="NOISE-CORE file not found.")
return FileResponse(path,media_type="audio/wav",filename=path.name)
@app.get("/api/v1/projects/{project_id}/noise/export")
def noise_export(project_id:str):
result=(service.manifest(project_id).get("noise") or {}).get("repair")
if not result:
raise HTTPException(status_code=409,detail="Approve and render repairs first.")
folder=service.folder(project_id)/"noisecore"/result["id"]
tmp=folder/f".{uuid.uuid4().hex}.zip"
target=folder/"NOISE_CORE_EXPORT.zip"
with zipfile.ZipFile(tmp,"w",compression=zipfile.ZIP_STORED) as archive:
archive.writestr("report.json",json.dumps(result,indent=2,ensure_ascii=False))
for name,entry in result["tracks"].items():
archive.write(folder/entry["master"],f"tracks/{entry['master']}")
tmp.replace(target)
return FileResponse(target,media_type="application/zip",
filename="ABSOLUTION_NOISE_CORE.zip")
@app.post("/api/v1/jobs/bass/virtual",status_code=202)
def create_virtual(request:VirtualBassRequest):
return service.create_virtualbass_job(request)
@app.get("/api/v1/projects/{project_id}/virtualbass")
def virtual_result(project_id:str):
return {"virtualbass":service.manifest(project_id).get("virtualbass")}
@app.get("/api/v1/projects/{project_id}/virtualbass/audio")
def virtual_audio(project_id:str):
result=service.manifest(project_id).get("virtualbass")
if not result:
raise HTTPException(status_code=404,detail="No Virtual Bass result.")
path=service.folder(project_id)/"virtualbass"/result["id"]/"virtualbass_2_1.wav"
if not path.is_file():
raise HTTPException(status_code=404,detail="Virtual Bass file not found.")
return FileResponse(path,media_type="audio/wav",filename="ABSOLUTION_VIRTUAL_BASS_2_1.wav")
@app.post("/api/v1/projects/{project_id}/inventory")
def run_inventory(project_id:str):
project_id=check_id(project_id)
with service.lock:
manifest=service.manifest(project_id)
if not manifest.get("asset"):
raise HTTPException(status_code=409,detail="Audio import required.")
path=service.folder(project_id)/manifest["asset"]["stored_name"]
try:
inventory=inspect_mini(path)
except (ValueError,FileNotFoundError) as exc:
raise HTTPException(status_code=422,detail=str(exc)) from exc
# Editable suggestions are hypotheses, NOT separated audio.
suggested=[{"id":d["id"],"label":d["label"],"enabled":True}
for d in inventory["detections"] if d["suggested"]]
manifest["inventory"]=inventory
if not manifest.get("plan"):manifest["plan"]=suggested
service.write_manifest(project_id,manifest)
return {"inventory":inventory,"plan":manifest["plan"],
"actual_stems":list(manifest.get("stems",{}))}
@app.put("/api/v1/projects/{project_id}/plan")
def update_plan(project_id:str,req:PlanRequest):
ids=[x.id for x in req.tracks]
if len(ids)!=len(set(ids)):
raise HTTPException(status_code=422,detail="Duplicate planned IDs.")
with service.lock:
manifest=service.manifest(project_id)
if not manifest.get("asset"):
raise HTTPException(status_code=409,detail="Import audio first.")
manifest["plan"]=[x.model_dump() for x in req.tracks]
service.write_manifest(project_id,manifest)
return {"plan":manifest["plan"],"status":"hypotheses_only",
"notice":"A saved plan does not separate or generate new stems."}
@app.get("/api/v1/projects/{project_id}/omnistem/plan")
def preview_omnistem_plan(project_id: str):
manifest = service.manifest(project_id)
if not manifest.get("asset"):
raise HTTPException(status_code=409, detail="Audio import required.")
active = service.active_tracks(manifest)
return compile_plan(manifest.get("plan") or [], active)
@app.post("/api/v1/projects/{project_id}/omnistem/run", status_code=202)
def run_omnistem_plan(project_id: str):
return service.create_omnistem_job(project_id)
@app.get("/api/v1/projects/{project_id}/omnistem/report")
def get_omnistem_report(project_id: str):
manifest = service.manifest(project_id)
return {"omnistem": manifest.get("omnistem")}
@app.get("/api/v1/projects/{project_id}/wave/{stem}")
def get_wave(project_id:str,stem:str,points:int=360):
manifest=service.manifest(project_id);folder=service.folder(project_id)
if stem=="original":
if not manifest.get("asset"):raise HTTPException(status_code=404,detail="No audio")
path=folder/manifest["asset"]["stored_name"]
else:
graph=manifest.get("unified")
active=service.active_tracks(manifest)
if stem not in active:
raise HTTPException(status_code=404,detail="Unknown stem")
path=folder/active[stem]["master"] if (graph and graph.get("mix_consistent")) else folder/"stems"/active[stem]["master"]
if points<64 or points>1000:
raise HTTPException(status_code=422,detail="points must be 64..1000")
try:return sampled_peaks(path,points)
except (ValueError,RuntimeError) as exc:
raise HTTPException(status_code=422,detail=str(exc)) from exc
@app.post("/api/v1/jobs/unify", status_code=202)
def start_unified(project_id: str):
return service.create_unified_job(project_id)
@app.get("/api/v1/projects/{project_id}/unified")
def get_unified(project_id: str):
m = service.manifest(project_id)
return {"unified": m.get("unified"), "active_stems": service.active_tracks(m)}
@app.post("/api/v1/jobs/mix",status_code=202)
def start_mix(request:MixerRequest):
return service.create_mixer_job(request)
@app.get("/api/v1/projects/{project_id}/mixer")
def mixer_status(project_id:str):
return {"mixer":service.manifest(project_id).get("mixer")}
@app.get("/api/v1/projects/{project_id}/mixer/audio")
def mixer_audio(project_id:str):
manifest=service.manifest(project_id)
mixer=manifest.get("mixer")
if not mixer:raise HTTPException(status_code=404,detail="Render a mix first.")
path=service.folder(project_id)/"mixer"/mixer["file"]
if not path.is_file():raise HTTPException(status_code=404,detail="Rendered mix missing")
return FileResponse(path,media_type="audio/wav",filename="ABSOLUTION_ARRANGEMENT_MIX.wav")
@app.get("/api/v1/projects/{project_id}/stems")
def get_stems(project_id: str):
manifest = service.manifest(project_id)
return {"stems": service.active_tracks(manifest), "report": manifest["report"],
"separation": manifest["separation"], "unified": manifest.get("unified")}
@app.get("/api/v1/projects/{project_id}/audio/{stem}")
def get_audio(project_id: str, stem: str, preview: bool = False):
folder = service.folder(project_id)
manifest = service.manifest(project_id)
if stem == "original":
if not manifest["asset"]:
raise HTTPException(status_code=404, detail="Audio not found.")
path = folder / ("original_preview.wav" if preview else manifest["asset"]["stored_name"])
else:
active = service.active_tracks(manifest)
if stem not in active:
raise HTTPException(status_code=404, detail="Stem not found.")
key = "preview" if preview else "master"
path = folder / active[stem][key] if (manifest.get("unified") or {}).get("mix_consistent") else folder / "stems" / active[stem][key]
if not path.is_file():
raise HTTPException(status_code=404, detail="Audio not found.")
return FileResponse(path, media_type="audio/wav" if preview or path.suffix == ".wav" else "application/octet-stream",
filename=path.name if not preview else None)
@app.get("/api/v1/projects/{project_id}/export")
def export_stems(project_id: str):
folder = service.folder(project_id)
manifest = service.manifest(project_id)
active = service.active_tracks(manifest)
if not active:
raise HTTPException(status_code=409, detail="Separate audio or build BASS/NOISE lanes before exporting.")
target = folder / "absolution_export.zip"
# Build only from controlled server-side names. Atomic replace.
tmp = folder / f".{uuid.uuid4().hex}.zip"
with zipfile.ZipFile(tmp, "w", compression=zipfile.ZIP_STORED) as archive:
archive.write(folder / "manifest.json", "manifest.json")
original_path = folder / manifest["asset"]["stored_name"]
archive.write(original_path, "source" + original_path.suffix)
for name,item in active.items():
path = folder/item["master"] if (manifest.get("unified") or {}).get("mix_consistent") else folder/"stems"/item["master"]
archive.write(path, "stems/" + name + ".wav")
tmp.replace(target)
return FileResponse(target, media_type="application/zip",
filename=f"tune-whisperer_{project_id[:8]}.zip")
return app
app = create_app()
"""Local-first FastAPI server for Tune-Whisperer (internal: ABSOLUTION Ω) v1.1.
No remote calls are made by this application. Jobs are process-local and not
durable; no public multi-user deployment without authorization is supported.
"""
from __future__ import annotations
import json
import importlib.util
import os
import threading
import uuid
import zipfile
from concurrent.futures import ThreadPoolExecutor
from datetime import datetime, timezone
from pathlib import Path
from typing import Literal
import numpy as np
import soundfile as sf
from fastapi import FastAPI, File, Form, HTTPException, UploadFile
from fastapi.responses import FileResponse, JSONResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel, Field
from .bass import BassParams, TRACKS, process_bass_file
from .noise import RepairParams, inspect_noise_file, repair_noise_file
from .virtualbass import available as virtualbass_available, render_virtualbass
from .mini_model import inspect_file as inspect_mini, MODEL_FILE
from .mixer import render_mix, sampled_peaks, rubberband_available
from .unified import build_unified_graph
from .omnistem import compile_plan, execute_plan
from . import access
import contextvars, secrets as _secrets
from http.cookies import SimpleCookie
from fastapi import Request
from fastapi.responses import RedirectResponse
from .audio import (
AudioError, align_and_resample, analyze_file, hpss_separate_file,
load_audio, mixture_report, save_stems, sha256_file,
)
# Byte quota protects local disk; no maximum duration is imposed on audio.
# Configure ABSOLUTION_MAX_UPLOAD_MIB to fit your available storage.
MAX_UPLOAD_MIB = max(1, min(4096, int(os.environ.get("ABSOLUTION_MAX_UPLOAD_MIB", "1024"))))
MAX_UPLOAD_BYTES = MAX_UPLOAD_MIB * 1024 * 1024
ALLOWED_EXTENSIONS = {".wav", ".flac", ".aif", ".aiff", ".mp3", ".ogg"}
def timestamp() -> str:
return datetime.now(timezone.utc).isoformat(timespec="seconds")
def check_id(raw: str) -> str:
try:
return str(uuid.UUID(raw))
except ValueError as exc:
raise HTTPException(status_code=404, detail="Project not found.") from exc
# Demucs on shared CPU hardware: cap input duration (0 = unlimited).
DEMUCS_MAX_SECONDS = float(os.environ.get("ABSOLUTION_DEMUCS_MAX_SECONDS", "0"))
class ProjectCreate(BaseModel):
name: str = Field(default="Untitled project", min_length=1, max_length=80)
class ProjectRename(BaseModel):
name: str = Field(min_length=1, max_length=80)
class FusionRequest(BaseModel):
project_id: str
mode: Literal["auto", "neural", "dsp"] = "auto"
include_event_proxies: bool = True
scan_noise: bool = True
class SeparationRequest(BaseModel):
project_id: str
model: Literal["hpss", "demucs"] = "hpss"
target_description: str = Field(default="", max_length=300)
class BassRequest(BaseModel):
project_id: str
source_mode: Literal["auto", "dsp", "hpss", "demucs"] = "auto"
crossover_hz: float = Field(default=220, ge=45, le=350)
kick_focus: float = Field(default=0.75, ge=0, le=1)
kick_gain_db: float = Field(default=0, ge=-12, le=12)
bass_gain_db: float = Field(default=0, ge=-12, le=12)
sub_gain_db: float = Field(default=0, ge=-12, le=12)
harmonics: float = Field(default=0.20, ge=0, le=1)
lowcut_hz: float = Field(default=22, ge=10, le=45)
mono_below_hz: float = Field(default=100, ge=0, le=180)
wet: float = Field(default=1, ge=0, le=1)
ceiling_dbfs: float = Field(default=-1, ge=-6, le=-0.1)