Stream previews and remove duplicate initial drum beat

README.md

@@ -23,7 +23,8 @@ on those beats. A continuous-F0 synth follows voice pitch and amplitude. A
 single YuE2 model load produces solo, melody-with-drums, and composition
 variants from the SheetSage2 ABC. YuE2 drums are requested in the style prompt,
 not imposed as a separate symbolic track. YuE2 can introduce voices or other
-sounds and does not preserve source timing exactly.
+sounds and does not preserve source timing exactly. The three deterministic
+previews appear first; YuE2 previews then appear as each generation finishes.
 
 Output audio is downloadable 320 kbit/s CBR MP3. This Space is public: uploads
 are processed on its Hugging Face server and results are served from temporary

app.py

@@ -34,7 +34,7 @@ def run(audio: str | None, instrument: str, solo_style: str, drum_style: str,
     try:
         styles = {"yue_solo": solo_style, "yue_drums": drum_style,
                   "yue_arrangement": arrangement_style}
-        return generate_all(audio, instrument, styles, int(seed), progress)
+        yield from generate_all(audio, instrument, styles, int(seed), progress)
     except Exception as error:
         raise gr.Error(str(error)) from error
 

logic.py

@@ -45,6 +45,11 @@ def drum_hits(beat_lab: str, melody_spans: list[tuple[float, float]],
         beats.append(Beat(time, int(position), int(meter)))
     if len(beats) < 3 or not melody_spans:
         raise ValueError("Для барабанов нужно хотя бы три доли и слышимая мелодия")
+    # SheetSage can emit a time-zero anchor immediately before its first real
+    # downbeat. Two adjacent beat-1 labels cannot both start the same measure.
+    if (beats[0].time == 0 and beats[0].position == beats[1].position == 1
+            and beats[0].meter == beats[1].meter):
+        beats = beats[1:]
     period = median(b.time - a.time for a, b in zip(beats, beats[1:]))
     if not 0.12 <= period <= 2.0:
         raise ValueError("Не удалось определить разумный темп барабанов")

pipeline.py

@@ -9,6 +9,7 @@ from pathlib import Path
 import subprocess
 import tempfile
 import time
+from typing import Iterator
 
 from logic import INSTRUMENTS, drum_hits, instrumental_abc, validate_duration
 
@@ -199,7 +200,7 @@ def render_contour(source: Path, folder: Path) -> Path:
 
 
 def render_yue_batch(melody_abc: Path, full_abc: Path, folder: Path,
-                     styles: dict[str, str], seed: int, log: Path) -> None:
+                     styles: dict[str, str], seed: int, log: Path) -> Iterator[str]:
     if not 0 <= seed < 2**31:
         raise ValueError("Seed должен быть целым числом от 0 до 2³¹−1")
     for style in styles.values():
@@ -219,8 +220,39 @@ def render_yue_batch(melody_abc: Path, full_abc: Path, folder: Path,
     ]}
     request_path = folder / "yue-requests.json"
     request_path.write_text(json.dumps(request, ensure_ascii=False, indent=2) + "\n")
-    command([str(YUE_PYTHON), str(ROOT / "yue_worker.py"),
-             str(request_path), str(folder)], log, timeout=1800)
+    pending = {run["name"] for run in request["runs"]}
+    with log.open("a") as stream:
+        process = subprocess.Popen([str(YUE_PYTHON), str(ROOT / "yue_worker.py"),
+                                    str(request_path), str(folder)],
+                                   stdout=stream, stderr=subprocess.STDOUT)
+        deadline = time.monotonic() + 1800
+        try:
+            while process.poll() is None:
+                for name in tuple(pending):
+                    target = folder / name
+                    if (target / "yue.json").is_file() or (target / "error.txt").is_file():
+                        pending.remove(name)
+                        yield name
+                if time.monotonic() > deadline:
+                    process.kill()
+                    process.wait()
+                    raise TimeoutError("YuE2 превысил лимит 30 минут")
+                time.sleep(1)
+            for name in tuple(pending):
+                target = folder / name
+                if (target / "yue.json").is_file() or (target / "error.txt").is_file():
+                    yield name
+            if process.returncode:
+                tail = "\n".join(log.read_text(errors="replace").splitlines()[-18:])
+                raise RuntimeError(f"YuE2 завершился с кодом {process.returncode}:\n{tail}")
+        finally:
+            if process.poll() is None:
+                process.terminate()
+                try:
+                    process.wait(timeout=5)
+                except subprocess.TimeoutExpired:
+                    process.kill()
+                    process.wait()
 
 
 def encode_mp3(source: Path, destination: Path, log: Path,
@@ -245,7 +277,7 @@ def encode_mp3(source: Path, destination: Path, log: Path,
 
 
 def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int,
-                 progress=None) -> tuple:
+                 progress=None) -> Iterator[tuple]:
     if not source or instrument not in INSTRUMENTS:
         raise ValueError("Загрузите или запишите напев и выберите инструмент")
     folder = Path(tempfile.mkdtemp(prefix="hum-"))
@@ -256,6 +288,8 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     outputs = {name: None for name in VARIANTS}
     errors = {}
     durations = {}
+    drum_count = 0
+    drums_midi = None
 
     def deliver(name: str, raw: Path, *, normalize: bool = True) -> None:
         destination = folder / f"{name}.mp3"
@@ -263,6 +297,18 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
         outputs[name] = str(destination)
         durations[name] = round(__import__("soundfile").info(raw).duration, 3)
 
+    def snapshot(*, complete: bool = False) -> tuple:
+        metadata = {"instrument": instrument, "source_sha256": digest,
+                    "source_seconds": round(duration, 3),
+                    "result_seconds": dict(durations), "drum_hits": drum_count,
+                    "errors": dict(errors), "complete": complete,
+                    "source_timing_preserved": ["instrument", "instrument_drums", "contour"],
+                    "yue_vocal_absence_guaranteed": False,
+                    "elapsed_seconds": round(time.monotonic() - began, 2)}
+        return (*(outputs[name] for name in VARIANTS), str(melody_midi),
+                str(drums_midi) if drums_midi else None, str(beat_lab),
+                str(folder / "instrumental-melody.abc"), metadata)
+
     if progress:
         progress(.02, desc="Проверяю и декодирую напев")
     pcm48, pcm24, duration = decode(uploaded, folder, log)
@@ -272,7 +318,6 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
     if progress:
         progress(.30, desc="Синтезирую инструмент и барабаны")
     melody_raw, melody_midi = render_instrument(midi, folder, instrument, duration, log)
-    drums_midi = None
     try:
         drums_raw, drums_midi, drum_count = render_drums(midi, beat_lab, folder,
                                                         duration, log)
@@ -289,13 +334,14 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
         deliver("contour", render_contour(pcm48, folder))
     except (ValueError, RuntimeError, OSError) as error:
         errors["contour"] = str(error)
+    (folder / "instrumental-melody.abc").write_text(
+        instrumental_abc(melody_abc.read_text()))
+    yield snapshot()
     if progress:
         progress(.50, desc="YuE2 создаёт сразу три варианта; это займёт несколько минут")
-    try:
-        render_yue_batch(melody_abc, full_abc, folder, styles, int(seed), log)
-    except (ValueError, RuntimeError, OSError) as error:
-        errors["yue_batch"] = str(error)
-    for name in VARIANTS[3:]:
+    completed = set()
+
+    def accept_yue(name: str) -> None:
         raw = folder / name / "raw.wav"
         if raw.is_file():
             try:
@@ -304,16 +350,21 @@ def generate_all(source: str, instrument: str, styles: dict[str, str], seed: int
                 errors[name] = str(error)
         else:
             detail = folder / name / "error.txt"
-            if detail.is_file():
-                errors[name] = detail.read_text(errors="replace").splitlines()[-1]
-    metadata = {"instrument": instrument, "source_sha256": digest,
-                "source_seconds": round(duration, 3), "result_seconds": durations,
-                "drum_hits": drum_count, "errors": errors,
-                "source_timing_preserved": ["instrument", "instrument_drums", "contour"],
-                "yue_vocal_absence_guaranteed": False,
-                "elapsed_seconds": round(time.monotonic() - began, 2)}
-    (folder / "result.json").write_text(json.dumps(metadata, ensure_ascii=False, indent=2) + "\n")
-    return (*(outputs[name] for name in VARIANTS), str(melody_midi),
-            str(drums_midi) if drums_midi else None, str(beat_lab),
-            str(folder / "instrumental-melody.abc") if (folder / "instrumental-melody.abc").is_file() else None,
-            metadata)
+            errors[name] = (detail.read_text(errors="replace").splitlines()[-1]
+                            if detail.is_file() else "YuE2 не вернул файл")
+        completed.add(name)
+
+    try:
+        for name in render_yue_batch(melody_abc, full_abc, folder, styles, int(seed), log):
+            accept_yue(name)
+            if progress:
+                progress(.50 + .15 * len(completed), desc=f"YuE2: {len(completed)} из 3 готовы")
+            yield snapshot()
+    except (ValueError, RuntimeError, OSError) as error:
+        errors["yue_batch"] = str(error)
+    for name in VARIANTS[3:]:
+        if name not in completed:
+            accept_yue(name)
+    final = snapshot(complete=True)
+    (folder / "result.json").write_text(json.dumps(final[-1], ensure_ascii=False, indent=2) + "\n")
+    yield final

test_logic.py

@@ -66,6 +66,14 @@ class LogicTest(unittest.TestCase):
             with self.assertRaises(ValueError):
                 drum_hits(beats, [(0.1, 1.1)], 2.0)
 
+    def test_drums_ignore_duplicate_zero_anchor_before_first_downbeat(self):
+        # Seen in the source-time SheetSage2 beat.lab for input-001.
+        beats = ("0\t1\t4\t4\n.44\t1\t4\t4\n.92\t2\t4\t4\n"
+                 "1.44\t3\t4\t4\n1.92\t4\t4\t4\n2.44\t1\t4\t4\n")
+        hits = drum_hits(beats, [(.22, 2.5)], 2.6)
+        self.assertFalse(any(time == 0 for time, _, _ in hits))
+        self.assertIn((.44, 36, 90), hits)
+
 
 if __name__ == "__main__":
     unittest.main()