Load synchronously in the worker, and keep a lossless container

Loads the model synchronously in the worker, moves the model card first, and returns a FLAC or AIFF input in its own container.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

app.py

@@ -8,7 +8,6 @@ import contextlib
 import tempfile
 import torch
 import os
-import threading
 import librosa
 import soundfile as sf
 import gradio as gr
@@ -18,18 +17,38 @@ from pyharp.tags import Subcategory
 
 from anyaccomp.inference_utils import Sing2SongInferencePipeline
 
+# Create a ModelCard describing this endpoint for HARP.
+model_card = ModelCard(
+    name="AnyAccomp",
+    description=(
+        "Upload a 3-30 second vocal or instrument track and the model will "
+        "generate an accompaniment. The code is MIT and the weights are "
+        "CC-BY-4.0, which requires attribution. Generation runs at 24 kHz in "
+        "mono; both outputs are resampled back to the input's rate and copied "
+        "across its channels, so they match the format they came in with but "
+        "carry no stereo image. Repository: "
+        "https://github.com/AmphionTeam/AnyAccomp Paper: "
+        "https://arxiv.org/abs/2509.14052"
+    ),
+    author="Junan Zhang, Yunjia Zhang, Xueyao Zhang, Zhizheng Wu",
+    tags=[Subcategory.ACCOMPANIMENT, SampleRate(24000), Channels(1), 'music'],
+)
+
+# A lossless input keeps its container. A lossy one comes back as WAV, since encoding the result
+# lossily again would expose the artifacts of the first encode and add a second set.
+LOSSLESS = {".wav", ".flac", ".aiff", ".aif"}
+
 repo_id = "amphion/anyaccomp"
 base_dir = os.path.dirname(os.path.abspath(__file__))
 DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
 
-# Model loading state. Populated by the background thread.
+# Model loading state, populated in the worker
 inference_pipeline = None
-model_loading = True
 model_error = None
 
 
 def load_model():
-    global inference_pipeline, model_loading, model_error
+    global inference_pipeline, model_error
     try:
         checkpoint_marker = os.path.join(base_dir, "pretrained", "flow_matching")
         if not os.path.exists(checkpoint_marker):
@@ -47,8 +66,7 @@ def load_model():
         vocoder_checkpoint_path = os.path.join(model_dir, "pretrained/vocoder")
 
         print("Initializing AnyAccomp InferencePipeline...", flush=True)
-        # Loaded on the CPU, since this runs in a background thread. The worker
-        # moves the modules to the GPU once loading is done (see below).
+        # Loaded on the CPU, and moved to the GPU once loading is done (see below)
         pipeline = Sing2SongInferencePipeline(
             checkpoint_path, cfg_path,
             vocoder_checkpoint_path, vocoder_cfg_path,
@@ -60,42 +78,16 @@ def load_model():
     except Exception as e:
         model_error = str(e)
         print(f"Error loading model: {e}", flush=True)
-    finally:
-        model_loading = False
 
 
-# Create a ModelCard describing this endpoint for HARP.
-model_card = ModelCard(
-    name="AnyAccomp",
-    description=(
-        "Upload a 3-30 second vocal or instrument track and the model will "
-        "generate an accompaniment. The code is MIT and the weights are "
-        "CC-BY-4.0, which requires attribution. Generation runs at 24 kHz in "
-        "mono; both outputs are resampled back to the input's rate and copied "
-        "across its channels, so they match the format they came in with but "
-        "carry no stereo image. Repository: "
-        "https://github.com/AmphionTeam/AnyAccomp Paper: "
-        "https://arxiv.org/abs/2509.14052"
-    ),
-    author="Junan Zhang, Yunjia Zhang, Xueyao Zhang, Zhizheng Wu",
-    tags=[Subcategory.ACCOMPANIMENT, SampleRate(24000), Channels(1), 'music'],
-)
-
-# Start model loading in the background so the server can start immediately.
-_loader = threading.Thread(target=load_model, daemon=True)
-_loader.start()
-
-# pyharp's worker imports this file to reach process_fn (as __mp_main__ rather than
-# __main__), so it finishes loading here, before process_fn can reserve a GPU, instead
-# of racing the check there. The server itself keeps loading in the background, which
-# lets it start at once.
+# pyharp runs process_fn in a worker, which imports this file as __mp_main__ (rather than
+# __main__) and starts with the server, so the model is downloaded and loaded there alone, before
+# process_fn can reserve a GPU. A failure is kept rather than raised, so that each request can
+# report it. ZeroGPU wants models placed on CUDA at module level, where its emulation records each
+# placement for every GPU call to replay, rather than inside the call, so the worker places them
+# here, on its main thread, once loading is done.
 if __name__ != "__main__":
-    _loader.join()
-
-    # ZeroGPU wants models placed on CUDA at module level, where its emulation records each
-    # placement for every GPU call to replay, rather than inside the call. The worker is the
-    # process that runs process_fn, so it places them here, on its main thread, once the
-    # loader is done. The server never runs process_fn, so its copy stays on the CPU.
+    load_model()
     if inference_pipeline is not None:
         for module in (inference_pipeline.model, inference_pipeline.coco_model,
                        inference_pipeline.vocoder):
@@ -106,8 +98,6 @@ if __name__ != "__main__":
 def process_fn(vocal_filepath, n_timesteps):  # add , cfg_scale to re-enable
     # Checked before the GPU is reserved, so a request the model cannot take spends none of the
     # caller's ZeroGPU allowance
-    if model_loading:
-        raise gr.Error("Model is still loading, please wait a moment and try again.")
     if inference_pipeline is None:
         raise gr.Error(f"Model failed to load: {model_error}")
 
@@ -154,9 +144,11 @@ def accompany(vocal_filepath, n_timesteps):
         wav = librosa.util.fix_length(data=wav, size=len(vocal_audio))
         mixture_wav = wav + vocal_audio
 
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+        input_ext = os.path.splitext(vocal_filepath)[1].lower()
+        output_ext = input_ext if input_ext in LOSSLESS else ".wav"
+        with tempfile.NamedTemporaryFile(suffix=output_ext, delete=False) as f:
             accompaniment_path = f.name
-        with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as f:
+        with tempfile.NamedTemporaryFile(suffix=output_ext, delete=False) as f:
             mixture_path = f.name
 
         def _restore(audio):