Files
2026-04-21 16:24:11 +09:00

672 lines
29 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, get_sep_power_preset,
)
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
from ..services.vram_estimates import VramBudgetExceededError, estimate_separation_vram_mb
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
def _submit_gpu_with_vram_guard(*, estimated_vram_mb: Optional[int], fn, args: tuple, kwargs: dict) -> None:
try:
jm.submit_gpu(fn, *args, estimated_vram_mb=estimated_vram_mb, **kwargs)
except VramBudgetExceededError as exc:
raise HTTPException(
status_code=507,
detail={
"error": "vram_budget_exceeded",
"required_mb": exc.required_mb,
"free_mb": exc.free_mb,
"reserve_mb": exc.reserve_mb,
"message": str(exc),
},
) from exc
def _resolve_effective_sep_power(_requested_sep_power_preset: Optional[str]) -> str:
"""Server-authoritative sep_power for all separation entry points.
This intentionally uses backend runtime settings/env as source-of-truth so
stale client-side values cannot silently force more aggressive presets.
"""
return get_sep_power_preset()
@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: Optional[str] = Form(None),
# 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)
# Resolve preset name for tracking
preset_label = "Standard"
if preset_type == "stems_only":
preset_label = "Quick"
elif preset_type == "instrumental":
preset_label = "Pro"
elif preset_type == "dynamic":
preset_label = "Rich"
elif preset_type == "static":
preset_label = f"Pro ({static_option})"
# 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
effective_sep_power_preset = _resolve_effective_sep_power(sep_power_preset)
estimated_vram_mb = estimate_separation_vram_mb(model, effective_sep_power_preset)
_submit_gpu_with_vram_guard(
estimated_vram_mb=estimated_vram_mb,
fn=run_separation,
args=(job_id, str(upload_path), model, output_format),
kwargs={
"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": effective_sep_power_preset,
"preset_name": preset_label,
"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,
"effective_sep_power_preset": effective_sep_power_preset,
}
@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: Optional[str] = Form(None),
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")
effective_sep_power_preset = _resolve_effective_sep_power(sep_power_preset)
estimated_vram_mb = estimate_separation_vram_mb(model, effective_sep_power_preset)
_submit_gpu_with_vram_guard(
estimated_vram_mb=estimated_vram_mb,
fn=run_separation,
args=(job_id, str(source_file), model, output_format),
kwargs={
"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": effective_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,
"effective_sep_power_preset": effective_sep_power_preset,
}
@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: Optional[str] = Form(None),
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")
effective_sep_power_preset = _resolve_effective_sep_power(sep_power_preset)
estimated_vram_mb = estimate_separation_vram_mb(model, effective_sep_power_preset)
_submit_gpu_with_vram_guard(
estimated_vram_mb=estimated_vram_mb,
fn=run_separation,
args=(job_id, str(source), model, output_format),
kwargs={
"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": effective_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,
"effective_sep_power_preset": effective_sep_power_preset,
}
@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