622 lines
26 KiB
Python
Executable File
622 lines
26 KiB
Python
Executable File
"""Stem separation endpoint with preset support."""
|
|
import json
|
|
import re
|
|
from pathlib import Path
|
|
from typing import Optional
|
|
|
|
from fastapi import APIRouter, Depends, File, Form, UploadFile, HTTPException
|
|
|
|
from .. import job_manager as jm
|
|
from ..config import (
|
|
UPLOAD_DIR, ALL_MODELS, ALL_MODEL_IDS, OUTPUT_FORMATS,
|
|
DEFAULT_MODEL, DEFAULT_OUTPUT_FORMAT, PRESET_TYPES, STATIC_OPTIONS,
|
|
IMPORTS_DIR,
|
|
)
|
|
from .models import get_runtime_availability
|
|
from ..security import require_admin_token
|
|
from ..services.instrument_models import parse_instrument_models_json
|
|
from ..services.separator_service import run_separation
|
|
from ..services.upload_io import save_upload_file
|
|
|
|
router = APIRouter(prefix="/api/separate", tags=["separate"])
|
|
|
|
VALID_FORMATS = {f["id"] for f in OUTPUT_FORMATS}
|
|
VALID_PRESETS = {p["id"] for p in PRESET_TYPES}
|
|
VALID_STATIC_OPTIONS = {o["id"] for o in STATIC_OPTIONS}
|
|
_MP3_BITRATE_RE = re.compile(r"^(?:96|112|128|160|192|224|256|320)k$")
|
|
_CHUNKING_MODES = {"auto", "always", "off"}
|
|
_POWER_TIERS = {"eco", "standard", "performance"}
|
|
_ALLOWED_AUDIO_UPLOAD_EXTS = {".mp3", ".wav", ".flac", ".m4a", ".ogg", ".aac", ".wma"}
|
|
_MAX_UPLOAD_FILENAME_LEN = 128
|
|
|
|
|
|
def _safe_basename(raw: str | None, fallback: str = "upload") -> str:
|
|
name = Path((raw or "").strip()).name.strip()
|
|
if not name or name.startswith("."):
|
|
name = fallback
|
|
if len(name) > _MAX_UPLOAD_FILENAME_LEN:
|
|
stem = Path(name).stem
|
|
ext = Path(name).suffix
|
|
keep_stem_len = max(1, _MAX_UPLOAD_FILENAME_LEN - len(ext))
|
|
name = f"{stem[:keep_stem_len]}{ext}" if ext else stem[:_MAX_UPLOAD_FILENAME_LEN]
|
|
return name
|
|
|
|
|
|
def _safe_audio_upload_filename(raw: str | None) -> str:
|
|
name = _safe_basename(raw, fallback="upload.mp3")
|
|
ext = Path(name).suffix.lower()
|
|
if ext not in _ALLOWED_AUDIO_UPLOAD_EXTS:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=(
|
|
f"Unsupported upload extension '{ext or '(none)'}'. "
|
|
f"Allowed: {sorted(_ALLOWED_AUDIO_UPLOAD_EXTS)}"
|
|
),
|
|
)
|
|
return name
|
|
|
|
|
|
def _safe_project_name(raw: str | None) -> str | None:
|
|
if raw is None:
|
|
return None
|
|
cleaned = Path(raw).name.strip()
|
|
if not cleaned or cleaned in {".", ".."}:
|
|
raise HTTPException(status_code=400, detail="Invalid project_name")
|
|
return cleaned
|
|
|
|
|
|
def _ensure_model_runtime_available(model_id: str) -> None:
|
|
available, reason = get_runtime_availability(model_id)
|
|
if not available:
|
|
raise HTTPException(status_code=400, detail=reason or f"Model '{model_id}' is unavailable in this runtime")
|
|
|
|
|
|
def _validate_mp3_bitrate(value: Optional[str], *, field_name: str) -> Optional[str]:
|
|
if value is None:
|
|
return None
|
|
cleaned = value.strip().lower()
|
|
if not cleaned:
|
|
return None
|
|
if not _MP3_BITRATE_RE.match(cleaned):
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=(
|
|
f"Invalid {field_name}: {value}. "
|
|
"Expected one of: 96k, 112k, 128k, 160k, 192k, 224k, 256k, 320k"
|
|
),
|
|
)
|
|
return cleaned
|
|
|
|
|
|
def _validate_chunking_mode(value: Optional[str]) -> Optional[str]:
|
|
if value is None:
|
|
return None
|
|
cleaned = value.strip().lower()
|
|
if not cleaned:
|
|
return None
|
|
if cleaned not in _CHUNKING_MODES:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail="Invalid chunking_mode_override. Expected: auto, always, off",
|
|
)
|
|
return cleaned
|
|
|
|
|
|
def _validate_positive_int(value: Optional[int], *, field_name: str, min_value: int = 1) -> Optional[int]:
|
|
if value is None:
|
|
return None
|
|
if int(value) < min_value:
|
|
raise HTTPException(status_code=400, detail=f"{field_name} must be >= {min_value}")
|
|
return int(value)
|
|
|
|
|
|
def _validate_float_range(
|
|
value: Optional[float], *, field_name: str, min_value: float, max_value: float
|
|
) -> Optional[float]:
|
|
if value is None:
|
|
return None
|
|
v = float(value)
|
|
if not (min_value <= v <= max_value):
|
|
raise HTTPException(status_code=400, detail=f"{field_name} must be between {min_value} and {max_value}")
|
|
return v
|
|
|
|
|
|
def _validate_power_tier(value: Optional[str], *, field_name: str) -> Optional[str]:
|
|
if value is None:
|
|
return None
|
|
cleaned = value.strip().lower()
|
|
if not cleaned:
|
|
return None
|
|
if cleaned not in _POWER_TIERS:
|
|
raise HTTPException(
|
|
status_code=400,
|
|
detail=f"{field_name} must be one of: eco, standard, performance",
|
|
)
|
|
return cleaned
|
|
|
|
|
|
@router.get("/models")
|
|
def get_models():
|
|
enriched = []
|
|
for model in ALL_MODELS:
|
|
available, reason = get_runtime_availability(model["id"])
|
|
enriched.append({
|
|
**model,
|
|
"available": available,
|
|
"unavailable_reason": reason,
|
|
})
|
|
return enriched
|
|
|
|
|
|
@router.get("/formats")
|
|
def get_formats():
|
|
return OUTPUT_FORMATS
|
|
|
|
|
|
@router.get("/presets")
|
|
def get_presets():
|
|
"""Get available preset types and options."""
|
|
return {
|
|
"preset_types": PRESET_TYPES,
|
|
"static_options": STATIC_OPTIONS,
|
|
}
|
|
|
|
|
|
@router.post("")
|
|
async def separate(
|
|
file: UploadFile = File(...),
|
|
model: str = Form(DEFAULT_MODEL),
|
|
output_format: str = Form(DEFAULT_OUTPUT_FORMAT),
|
|
# Preset options
|
|
preset_type: str = Form("stems_only"),
|
|
static_option: Optional[str] = Form(None),
|
|
dynamic_levels: Optional[str] = Form(None), # JSON string: {"vocals": 1.0, ...}
|
|
# Project naming
|
|
project_name: Optional[str] = Form(None),
|
|
# Optional per-instrument refinement mapping (JSON object)
|
|
instrument_models: Optional[str] = Form(None),
|
|
instrument_refine_output_format: Optional[str] = Form(None),
|
|
instrument_refine_mp3_bitrate: Optional[str] = Form(None),
|
|
mp3_bitrate: Optional[str] = Form(None),
|
|
# Power preset
|
|
sep_power_preset: str = Form("standard"),
|
|
# Phase 4: optional request-level runtime overrides
|
|
chunking_mode_override: Optional[str] = Form(None),
|
|
chunk_duration_secs_override: Optional[int] = Form(None),
|
|
chunk_overlap_secs_override: Optional[int] = Form(None),
|
|
roformer_batch_size_override: Optional[int] = Form(None),
|
|
roformer_num_overlap_override: Optional[int] = Form(None),
|
|
demucs_segment_override: Optional[int] = Form(None),
|
|
demucs_overlap_override: Optional[float] = Form(None),
|
|
scnet_chunk_size_override: Optional[int] = Form(None),
|
|
scnet_num_overlap_override: Optional[int] = Form(None),
|
|
global_power_tier_override: Optional[str] = Form(None),
|
|
global_segment_secs_override: Optional[float] = Form(None),
|
|
global_overlap_override: Optional[float] = Form(None),
|
|
global_batch_size_override: Optional[int] = Form(None),
|
|
_admin_guard: None = Depends(require_admin_token),
|
|
):
|
|
"""
|
|
Separate audio into stems with optional preset mixing.
|
|
|
|
Args:
|
|
file: Audio file to process
|
|
model: Separation model ID
|
|
output_format: Output audio format
|
|
preset_type: Type of preset mix to create (stems_only, instrumental, static, dynamic)
|
|
static_option: For static preset, which stems to remove
|
|
dynamic_levels: For dynamic preset, JSON dict of stem name to volume multiplier (0.0-2.0)
|
|
project_name: Override auto-generated project name
|
|
"""
|
|
# Validate inputs
|
|
if model not in ALL_MODEL_IDS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
|
|
_ensure_model_runtime_available(model)
|
|
if output_format not in VALID_FORMATS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown format: {output_format}")
|
|
if preset_type not in VALID_PRESETS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown preset type: {preset_type}")
|
|
|
|
if preset_type == 'static' and static_option and static_option not in VALID_STATIC_OPTIONS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown static option: {static_option}")
|
|
if instrument_refine_output_format and instrument_refine_output_format not in VALID_FORMATS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown format: {instrument_refine_output_format}")
|
|
|
|
validated_mp3_bitrate = _validate_mp3_bitrate(mp3_bitrate, field_name="mp3_bitrate")
|
|
validated_refine_mp3_bitrate = _validate_mp3_bitrate(
|
|
instrument_refine_mp3_bitrate,
|
|
field_name="instrument_refine_mp3_bitrate",
|
|
)
|
|
validated_chunking_mode = _validate_chunking_mode(chunking_mode_override)
|
|
validated_chunk_duration = _validate_positive_int(
|
|
chunk_duration_secs_override,
|
|
field_name="chunk_duration_secs_override",
|
|
)
|
|
validated_chunk_overlap = _validate_positive_int(
|
|
chunk_overlap_secs_override,
|
|
field_name="chunk_overlap_secs_override",
|
|
min_value=0,
|
|
)
|
|
validated_roformer_batch_size = _validate_positive_int(
|
|
roformer_batch_size_override,
|
|
field_name="roformer_batch_size_override",
|
|
)
|
|
validated_roformer_num_overlap = _validate_positive_int(
|
|
roformer_num_overlap_override,
|
|
field_name="roformer_num_overlap_override",
|
|
)
|
|
validated_demucs_segment = _validate_positive_int(
|
|
demucs_segment_override,
|
|
field_name="demucs_segment_override",
|
|
)
|
|
validated_demucs_overlap = _validate_float_range(
|
|
demucs_overlap_override,
|
|
field_name="demucs_overlap_override",
|
|
min_value=0.0,
|
|
max_value=0.95,
|
|
)
|
|
validated_scnet_chunk_size = _validate_positive_int(
|
|
scnet_chunk_size_override,
|
|
field_name="scnet_chunk_size_override",
|
|
)
|
|
validated_scnet_num_overlap = _validate_positive_int(
|
|
scnet_num_overlap_override,
|
|
field_name="scnet_num_overlap_override",
|
|
)
|
|
validated_global_power_tier = _validate_power_tier(
|
|
global_power_tier_override,
|
|
field_name="global_power_tier_override",
|
|
)
|
|
validated_global_segment_secs = _validate_float_range(
|
|
global_segment_secs_override,
|
|
field_name="global_segment_secs_override",
|
|
min_value=0.1,
|
|
max_value=3600.0,
|
|
)
|
|
validated_global_overlap = _validate_float_range(
|
|
global_overlap_override,
|
|
field_name="global_overlap_override",
|
|
min_value=0.0,
|
|
max_value=16.0,
|
|
)
|
|
validated_global_batch_size = _validate_positive_int(
|
|
global_batch_size_override,
|
|
field_name="global_batch_size_override",
|
|
)
|
|
|
|
# Parse dynamic levels JSON
|
|
parsed_dynamic_levels = None
|
|
if dynamic_levels:
|
|
try:
|
|
parsed_dynamic_levels = json.loads(dynamic_levels)
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=400, detail="Invalid dynamic_levels JSON")
|
|
|
|
try:
|
|
parsed_instrument_models = parse_instrument_models_json(instrument_models)
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
|
|
safe_project_name = _safe_project_name(project_name)
|
|
|
|
# Create job
|
|
job_id = jm.create_job("separate")
|
|
upload_dir = UPLOAD_DIR / job_id
|
|
upload_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
# Save uploaded file
|
|
upload_path = upload_dir / _safe_audio_upload_filename(file.filename)
|
|
await save_upload_file(file, upload_path)
|
|
|
|
# Submit job with all options
|
|
jm.submit_gpu(
|
|
run_separation,
|
|
job_id,
|
|
str(upload_path),
|
|
model,
|
|
output_format,
|
|
preset_type=preset_type,
|
|
static_option=static_option,
|
|
dynamic_levels=parsed_dynamic_levels,
|
|
instrument_models=parsed_instrument_models,
|
|
instrument_refine_output_format=instrument_refine_output_format,
|
|
instrument_refine_mp3_bitrate=validated_refine_mp3_bitrate,
|
|
mp3_bitrate_override=validated_mp3_bitrate,
|
|
project_name_override=safe_project_name,
|
|
sep_power_preset=sep_power_preset,
|
|
chunking_mode_override=validated_chunking_mode,
|
|
chunk_duration_secs_override=validated_chunk_duration,
|
|
chunk_overlap_secs_override=validated_chunk_overlap,
|
|
roformer_batch_size_override=validated_roformer_batch_size,
|
|
roformer_num_overlap_override=validated_roformer_num_overlap,
|
|
demucs_segment_override=validated_demucs_segment,
|
|
demucs_overlap_override=validated_demucs_overlap,
|
|
scnet_chunk_size_override=validated_scnet_chunk_size,
|
|
scnet_num_overlap_override=validated_scnet_num_overlap,
|
|
global_power_tier_override=validated_global_power_tier,
|
|
global_segment_secs_override=validated_global_segment_secs,
|
|
global_overlap_override=validated_global_overlap,
|
|
global_batch_size_override=validated_global_batch_size,
|
|
)
|
|
|
|
return {
|
|
"job_id": job_id,
|
|
"preset_type": preset_type,
|
|
"project_name": safe_project_name,
|
|
}
|
|
|
|
|
|
@router.post("/existing")
|
|
async def separate_existing(
|
|
project_name: str = Form(..., description="Project name to process"),
|
|
model: str = Form(DEFAULT_MODEL),
|
|
output_format: str = Form(DEFAULT_OUTPUT_FORMAT),
|
|
preset_type: str = Form("stems_only"),
|
|
static_option: Optional[str] = Form(None),
|
|
dynamic_levels: Optional[str] = Form(None),
|
|
instrument_models: Optional[str] = Form(None),
|
|
instrument_refine_output_format: Optional[str] = Form(None),
|
|
instrument_refine_mp3_bitrate: Optional[str] = Form(None),
|
|
mp3_bitrate: Optional[str] = Form(None),
|
|
sep_power_preset: str = Form("standard"),
|
|
chunking_mode_override: Optional[str] = Form(None),
|
|
chunk_duration_secs_override: Optional[int] = Form(None),
|
|
chunk_overlap_secs_override: Optional[int] = Form(None),
|
|
roformer_batch_size_override: Optional[int] = Form(None),
|
|
roformer_num_overlap_override: Optional[int] = Form(None),
|
|
demucs_segment_override: Optional[int] = Form(None),
|
|
demucs_overlap_override: Optional[float] = Form(None),
|
|
scnet_chunk_size_override: Optional[int] = Form(None),
|
|
scnet_num_overlap_override: Optional[int] = Form(None),
|
|
global_power_tier_override: Optional[str] = Form(None),
|
|
global_segment_secs_override: Optional[float] = Form(None),
|
|
global_overlap_override: Optional[float] = Form(None),
|
|
global_batch_size_override: Optional[int] = Form(None),
|
|
_admin_guard: None = Depends(require_admin_token),
|
|
):
|
|
"""
|
|
Re-run separation on an existing project (if source audio exists).
|
|
"""
|
|
from ..config import PROJECTS_DIR
|
|
|
|
if model not in ALL_MODEL_IDS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
|
|
_ensure_model_runtime_available(model)
|
|
if output_format not in VALID_FORMATS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown format: {output_format}")
|
|
if instrument_refine_output_format and instrument_refine_output_format not in VALID_FORMATS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown format: {instrument_refine_output_format}")
|
|
if preset_type not in VALID_PRESETS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown preset type: {preset_type}")
|
|
|
|
validated_mp3_bitrate = _validate_mp3_bitrate(mp3_bitrate, field_name="mp3_bitrate")
|
|
validated_refine_mp3_bitrate = _validate_mp3_bitrate(
|
|
instrument_refine_mp3_bitrate,
|
|
field_name="instrument_refine_mp3_bitrate",
|
|
)
|
|
validated_chunking_mode = _validate_chunking_mode(chunking_mode_override)
|
|
validated_chunk_duration = _validate_positive_int(chunk_duration_secs_override, field_name="chunk_duration_secs_override")
|
|
validated_chunk_overlap = _validate_positive_int(chunk_overlap_secs_override, field_name="chunk_overlap_secs_override", min_value=0)
|
|
validated_roformer_batch_size = _validate_positive_int(roformer_batch_size_override, field_name="roformer_batch_size_override")
|
|
validated_roformer_num_overlap = _validate_positive_int(roformer_num_overlap_override, field_name="roformer_num_overlap_override")
|
|
validated_demucs_segment = _validate_positive_int(demucs_segment_override, field_name="demucs_segment_override")
|
|
validated_demucs_overlap = _validate_float_range(demucs_overlap_override, field_name="demucs_overlap_override", min_value=0.0, max_value=0.95)
|
|
validated_scnet_chunk_size = _validate_positive_int(scnet_chunk_size_override, field_name="scnet_chunk_size_override")
|
|
validated_scnet_num_overlap = _validate_positive_int(scnet_num_overlap_override, field_name="scnet_num_overlap_override")
|
|
validated_global_power_tier = _validate_power_tier(global_power_tier_override, field_name="global_power_tier_override")
|
|
validated_global_segment_secs = _validate_float_range(global_segment_secs_override, field_name="global_segment_secs_override", min_value=0.1, max_value=3600.0)
|
|
validated_global_overlap = _validate_float_range(global_overlap_override, field_name="global_overlap_override", min_value=0.0, max_value=16.0)
|
|
validated_global_batch_size = _validate_positive_int(global_batch_size_override, field_name="global_batch_size_override")
|
|
|
|
safe_project_name = _safe_project_name(project_name)
|
|
if not safe_project_name:
|
|
raise HTTPException(status_code=400, detail="Invalid project_name")
|
|
|
|
project_dir = PROJECTS_DIR / safe_project_name
|
|
if not project_dir.exists():
|
|
raise HTTPException(status_code=404, detail=f"Project not found: {safe_project_name}")
|
|
|
|
# Look for source audio file
|
|
source_file = None
|
|
for ext in ['.mp3', '.flac', '.wav', '.m4a', '.ogg']:
|
|
candidate = project_dir / f"{safe_project_name}{ext}"
|
|
if candidate.exists():
|
|
source_file = candidate
|
|
break
|
|
# Check for any file with source-like name
|
|
for f in project_dir.iterdir():
|
|
if f.suffix.lower() == ext and 'source' in f.name.lower():
|
|
source_file = f
|
|
break
|
|
if source_file:
|
|
break
|
|
|
|
if not source_file:
|
|
raise HTTPException(status_code=404, detail="Source audio file not found")
|
|
|
|
# Parse dynamic levels
|
|
parsed_dynamic_levels = None
|
|
if dynamic_levels:
|
|
try:
|
|
parsed_dynamic_levels = json.loads(dynamic_levels)
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=400, detail="Invalid dynamic_levels JSON")
|
|
|
|
try:
|
|
parsed_instrument_models = parse_instrument_models_json(instrument_models)
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
|
|
# Create job
|
|
job_id = jm.create_job("separate")
|
|
|
|
jm.submit_gpu(
|
|
run_separation,
|
|
job_id,
|
|
str(source_file),
|
|
model,
|
|
output_format,
|
|
preset_type=preset_type,
|
|
static_option=static_option,
|
|
dynamic_levels=parsed_dynamic_levels,
|
|
instrument_models=parsed_instrument_models,
|
|
instrument_refine_output_format=instrument_refine_output_format,
|
|
instrument_refine_mp3_bitrate=validated_refine_mp3_bitrate,
|
|
mp3_bitrate_override=validated_mp3_bitrate,
|
|
project_name_override=safe_project_name,
|
|
sep_power_preset=sep_power_preset,
|
|
chunking_mode_override=validated_chunking_mode,
|
|
chunk_duration_secs_override=validated_chunk_duration,
|
|
chunk_overlap_secs_override=validated_chunk_overlap,
|
|
roformer_batch_size_override=validated_roformer_batch_size,
|
|
roformer_num_overlap_override=validated_roformer_num_overlap,
|
|
demucs_segment_override=validated_demucs_segment,
|
|
demucs_overlap_override=validated_demucs_overlap,
|
|
scnet_chunk_size_override=validated_scnet_chunk_size,
|
|
scnet_num_overlap_override=validated_scnet_num_overlap,
|
|
global_power_tier_override=validated_global_power_tier,
|
|
global_segment_secs_override=validated_global_segment_secs,
|
|
global_overlap_override=validated_global_overlap,
|
|
global_batch_size_override=validated_global_batch_size,
|
|
)
|
|
|
|
return {
|
|
"job_id": job_id,
|
|
"preset_type": preset_type,
|
|
"project_name": safe_project_name,
|
|
}
|
|
|
|
|
|
@router.post("/from-path")
|
|
async def separate_from_path(
|
|
file_path: str = Form(...),
|
|
model: str = Form(DEFAULT_MODEL),
|
|
output_format: str = Form(DEFAULT_OUTPUT_FORMAT),
|
|
preset_type: str = Form("stems_only"),
|
|
static_option: Optional[str] = Form(None),
|
|
dynamic_levels: Optional[str] = Form(None),
|
|
instrument_models: Optional[str] = Form(None),
|
|
instrument_refine_output_format: Optional[str] = Form(None),
|
|
instrument_refine_mp3_bitrate: Optional[str] = Form(None),
|
|
mp3_bitrate: Optional[str] = Form(None),
|
|
project_name: Optional[str] = Form(None),
|
|
sep_power_preset: str = Form("standard"),
|
|
chunking_mode_override: Optional[str] = Form(None),
|
|
chunk_duration_secs_override: Optional[int] = Form(None),
|
|
chunk_overlap_secs_override: Optional[int] = Form(None),
|
|
roformer_batch_size_override: Optional[int] = Form(None),
|
|
roformer_num_overlap_override: Optional[int] = Form(None),
|
|
demucs_segment_override: Optional[int] = Form(None),
|
|
demucs_overlap_override: Optional[float] = Form(None),
|
|
scnet_chunk_size_override: Optional[int] = Form(None),
|
|
scnet_num_overlap_override: Optional[int] = Form(None),
|
|
global_power_tier_override: Optional[str] = Form(None),
|
|
global_segment_secs_override: Optional[float] = Form(None),
|
|
global_overlap_override: Optional[float] = Form(None),
|
|
global_batch_size_override: Optional[int] = Form(None),
|
|
_admin_guard: None = Depends(require_admin_token),
|
|
):
|
|
"""
|
|
Separate a server-side audio file (e.g., imported from Subsonic).
|
|
Only files inside IMPORTS_DIR are accepted for security.
|
|
"""
|
|
if model not in ALL_MODEL_IDS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown model: {model}")
|
|
_ensure_model_runtime_available(model)
|
|
if output_format not in VALID_FORMATS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown format: {output_format}")
|
|
if instrument_refine_output_format and instrument_refine_output_format not in VALID_FORMATS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown format: {instrument_refine_output_format}")
|
|
if preset_type not in VALID_PRESETS:
|
|
raise HTTPException(status_code=400, detail=f"Unknown preset type: {preset_type}")
|
|
|
|
validated_mp3_bitrate = _validate_mp3_bitrate(mp3_bitrate, field_name="mp3_bitrate")
|
|
validated_refine_mp3_bitrate = _validate_mp3_bitrate(
|
|
instrument_refine_mp3_bitrate,
|
|
field_name="instrument_refine_mp3_bitrate",
|
|
)
|
|
validated_chunking_mode = _validate_chunking_mode(chunking_mode_override)
|
|
validated_chunk_duration = _validate_positive_int(chunk_duration_secs_override, field_name="chunk_duration_secs_override")
|
|
validated_chunk_overlap = _validate_positive_int(chunk_overlap_secs_override, field_name="chunk_overlap_secs_override", min_value=0)
|
|
validated_roformer_batch_size = _validate_positive_int(roformer_batch_size_override, field_name="roformer_batch_size_override")
|
|
validated_roformer_num_overlap = _validate_positive_int(roformer_num_overlap_override, field_name="roformer_num_overlap_override")
|
|
validated_demucs_segment = _validate_positive_int(demucs_segment_override, field_name="demucs_segment_override")
|
|
validated_demucs_overlap = _validate_float_range(demucs_overlap_override, field_name="demucs_overlap_override", min_value=0.0, max_value=0.95)
|
|
validated_scnet_chunk_size = _validate_positive_int(scnet_chunk_size_override, field_name="scnet_chunk_size_override")
|
|
validated_scnet_num_overlap = _validate_positive_int(scnet_num_overlap_override, field_name="scnet_num_overlap_override")
|
|
validated_global_power_tier = _validate_power_tier(global_power_tier_override, field_name="global_power_tier_override")
|
|
validated_global_segment_secs = _validate_float_range(global_segment_secs_override, field_name="global_segment_secs_override", min_value=0.1, max_value=3600.0)
|
|
validated_global_overlap = _validate_float_range(global_overlap_override, field_name="global_overlap_override", min_value=0.0, max_value=16.0)
|
|
validated_global_batch_size = _validate_positive_int(global_batch_size_override, field_name="global_batch_size_override")
|
|
|
|
source = Path(file_path)
|
|
if not source.exists() or not source.is_file():
|
|
raise HTTPException(status_code=404, detail="File not found")
|
|
|
|
# Security: reject paths that escape IMPORTS_DIR
|
|
try:
|
|
source.resolve().relative_to(IMPORTS_DIR.resolve())
|
|
except ValueError:
|
|
raise HTTPException(status_code=403, detail="File is not in the imports directory")
|
|
|
|
safe_project_name = _safe_project_name(project_name)
|
|
|
|
parsed_dynamic_levels = None
|
|
if dynamic_levels:
|
|
try:
|
|
parsed_dynamic_levels = json.loads(dynamic_levels)
|
|
except json.JSONDecodeError:
|
|
raise HTTPException(status_code=400, detail="Invalid dynamic_levels JSON")
|
|
|
|
try:
|
|
parsed_instrument_models = parse_instrument_models_json(instrument_models)
|
|
except ValueError as exc:
|
|
raise HTTPException(status_code=400, detail=str(exc)) from exc
|
|
|
|
job_id = jm.create_job("separate")
|
|
jm.submit_gpu(
|
|
run_separation,
|
|
job_id,
|
|
str(source),
|
|
model,
|
|
output_format,
|
|
preset_type=preset_type,
|
|
static_option=static_option,
|
|
dynamic_levels=parsed_dynamic_levels,
|
|
instrument_models=parsed_instrument_models,
|
|
instrument_refine_output_format=instrument_refine_output_format,
|
|
instrument_refine_mp3_bitrate=validated_refine_mp3_bitrate,
|
|
mp3_bitrate_override=validated_mp3_bitrate,
|
|
project_name_override=safe_project_name or source.stem,
|
|
sep_power_preset=sep_power_preset,
|
|
chunking_mode_override=validated_chunking_mode,
|
|
chunk_duration_secs_override=validated_chunk_duration,
|
|
chunk_overlap_secs_override=validated_chunk_overlap,
|
|
roformer_batch_size_override=validated_roformer_batch_size,
|
|
roformer_num_overlap_override=validated_roformer_num_overlap,
|
|
demucs_segment_override=validated_demucs_segment,
|
|
demucs_overlap_override=validated_demucs_overlap,
|
|
scnet_chunk_size_override=validated_scnet_chunk_size,
|
|
scnet_num_overlap_override=validated_scnet_num_overlap,
|
|
global_power_tier_override=validated_global_power_tier,
|
|
global_segment_secs_override=validated_global_segment_secs,
|
|
global_overlap_override=validated_global_overlap,
|
|
global_batch_size_override=validated_global_batch_size,
|
|
)
|
|
|
|
return {"job_id": job_id, "preset_type": preset_type}
|
|
|
|
|
|
@router.get("/per-instrument-models")
|
|
def get_per_instrument_models():
|
|
"""Get all separation models available for per-stem reprocessing."""
|
|
enriched = []
|
|
for model in ALL_MODELS:
|
|
available, reason = get_runtime_availability(model["id"])
|
|
enriched.append({
|
|
**model,
|
|
"available": available,
|
|
"unavailable_reason": reason,
|
|
})
|
|
return enriched
|