diff --git a/CLAUDE.md b/CLAUDE.md index 0da1775..7dbf3f7 100644 --- a/CLAUDE.md +++ b/CLAUDE.md @@ -429,7 +429,12 @@ persistence) → GUI (Qt widgets that read the manager and connect to its signal memoizes path + size + mtime → key; old path-keyed folders are renamed on sight. The cache is held to config.json's `dj_stem_cache_gb` (Preferences › DJ, default 1): after each split the least recently used - songs go (`stems.prune`). + songs go (`stems.prune`). **Round 102**: a tiny ✕ after a deck's + vocals note while it waits for or runs Demucs ("cancel vocals split") + calls `StemSplitter.cancel` — out of the queue, or Demucs killed by + `split`'s watcher thread at once (it can go seconds without a progress + line). The slider then stays enabled, and grabbing it (or loading the + song again) splits it over. **Prepare for DJ** (a playlist's or songs' right-click; `dj/prepare.py`) does the BPM + split ahead of time with the status-bar progress/cancel. Each deck also has a volume fader (outer edge, perceptual), a ½×/1×/2× diff --git a/lintunes/__init__.py b/lintunes/__init__.py index 7aa74b0..d84e277 100644 --- a/lintunes/__init__.py +++ b/lintunes/__init__.py @@ -1,3 +1,3 @@ """LinTunes — iTunes-style music library manager and player for Linux.""" -__version__ = "0.70.0" +__version__ = "0.71.0" diff --git a/lintunes/dj/stems.py b/lintunes/dj/stems.py index 6f0b7b7..da70db0 100644 --- a/lintunes/dj/stems.py +++ b/lintunes/dj/stems.py @@ -295,14 +295,23 @@ def split(path: str, model: str, gentle: bool, progress=None, + ["--flac", "-o", str(work), path]) process = subprocess.Popen(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.PIPE, env=env, preexec_fn=lambda: os.nice(niceness)) + if cancel is not None: + def watch(): + # Demucs can go seconds without a progress line (loading the + # model), so a cancel kills it from here rather than waiting. + while process.poll() is None: + if cancel.wait(0.2): + process.kill() + return + threading.Thread(target=watch, daemon=True, name="lintunes-demucs-watch").start() tail = b"" last = -1 while True: + chunk = process.stderr.read(256) if cancel is not None and cancel.is_set(): process.kill() process.wait() raise Cancelled() - chunk = process.stderr.read(256) if not chunk: break tail = (tail + chunk)[-4096:] @@ -338,6 +347,7 @@ class StemSplitter(QObject): progress = pyqtSignal(str, int) # path, percent finished = pyqtSignal(str, object) # path, {"vocals": Path, …} failed = pyqtSignal(str, str) # path, why + cancelled = pyqtSignal(str) # path def __init__(self, settings=None, parent=None): super().__init__(parent) @@ -345,13 +355,32 @@ class StemSplitter(QObject): self._queue: list[str] = [] self._busy = False self._lock = threading.Lock() + self._running: str | None = None + self._stop = threading.Event() + self._called_off: set[str] = set() def request(self, path: str): """Split ``path`` unless any split of it is cached (then report it). The lookup may hash the audio (~0.2 s), so it runs off this thread.""" + with self._lock: + self._called_off.discard(path) threading.Thread(target=self._look_up, args=(path,), daemon=True, name="lintunes-stems-lookup").start() + def cancel(self, path: str): + """Stop splitting ``path``: out of the queue, or Demucs killed if it + is the one running. Emits ``cancelled``; a later ``request`` starts + it over.""" + with self._lock: + self._called_off.add(path) + queued = path in self._queue + if queued: + self._queue.remove(path) + if self._running == path: + self._stop.set() + return # _run reports it once Demucs is gone + self.cancelled.emit(path) + def _look_up(self, path: str): hit = cached(path) if hit is not None: @@ -361,7 +390,7 @@ class StemSplitter(QObject): def _enqueue(self, path: str): with self._lock: - if path in self._queue: + if path in self._called_off or path in self._queue: return self._queue.append(path) start = not self._busy @@ -377,11 +406,23 @@ class StemSplitter(QObject): self._busy = False return path = self._queue.pop(0) + self._running = path + self._stop.clear() model, gentle = self._settings() try: result = split(path, model, gentle, - lambda percent, path=path: self.progress.emit(path, percent)) + lambda percent, path=path: self.progress.emit(path, percent), + self._stop) + except Cancelled: + with self._lock: + still_off = path in self._called_off + if still_off: # not asked for again while Demucs died + self.cancelled.emit(path) + continue except Exception as e: # noqa: BLE001 — reported, never raised self.failed.emit(path, str(e) or type(e).__name__) continue + finally: + with self._lock: + self._running = None self.finished.emit(path, result) diff --git a/lintunes/gui/dj_shelf.py b/lintunes/gui/dj_shelf.py index 53df715..1c462fd 100644 --- a/lintunes/gui/dj_shelf.py +++ b/lintunes/gui/dj_shelf.py @@ -69,6 +69,8 @@ class DeckView: self.bpm: float | None = None self.offset = 0.0 self.stem_note = "" + self.splitting = False # waiting for / running Demucs (the ✕ shows) + self.split_called_off = False # cancelled: grabbing the slider retries self.bpm_saved = False self.counted = False self.mult = 1.0 # the ½× / 1× / 2× switch @@ -609,6 +611,7 @@ class SnapSlider(QWidget): ``home``. ``tint`` colours the handle (a deck's colour), None is grey.""" valueChanged = pyqtSignal(int) + sliderPressed = pyqtSignal() TRACK = 8 def __init__(self, vertical: bool, lo: int, hi: int, *, home: int = 0, @@ -678,6 +681,7 @@ class SnapSlider(QWidget): def mousePressEvent(self, event): if event.button() == Qt.MouseButton.LeftButton: self._dragging = True + self.sliderPressed.emit() self.setValue(self._snapped(self._value_at(event.position()))) def mouseMoveEvent(self, event): @@ -1054,6 +1058,7 @@ class DjShelf(QWidget): self._splitter.progress.connect(self._on_stem_progress) self._splitter.finished.connect(self._on_stems) self._splitter.failed.connect(self._on_stem_failed) + self._splitter.cancelled.connect(self._on_stem_cancelled) self.setAutoFillBackground(False) self.setAttribute(Qt.WidgetAttribute.WA_StyledBackground, False) self._build() @@ -1092,6 +1097,7 @@ class DjShelf(QWidget): self.sync_buttons = {} self.vocal_sliders = {} self.stem_labels = {} + self.stem_cancel = {} self.titles = {} self.states = {} self.bpm_labels = {} @@ -1265,11 +1271,32 @@ class DjShelf(QWidget): slider = VocalSlider(v.color) slider.valueChanged.connect(lambda value, v=v: setattr(v.deck, "vocal_mix", value / 100)) + slider.sliderPressed.connect(lambda v=v: self._retry_split(v)) col.addWidget(slider) stem = QLabel("") stem.setStyleSheet(f"color: {DIM}; font-size: 10px;") stem.setAlignment(align) - col.addWidget(stem) + # A tiny ✕ right after the note while Demucs is on this song. + stop = QToolButton() + stop.setText("✕") + stop.setToolTip("cancel vocals split") + stop.setAutoRaise(True) + stop.setFocusPolicy(Qt.FocusPolicy.NoFocus) + stop.setCursor(Qt.CursorShape.PointingHandCursor) + stop.setStyleSheet(f"QToolButton {{ color: {DIM}; font-size: 10px; border: none;" + f" padding: 0 2px; background: transparent; }}" + f"QToolButton:hover {{ color: #f4f4f4; }}") + stop.clicked.connect(lambda _=False, v=v: self.cancel_split(v)) + stop.hide() + note_line = QHBoxLayout() + note_line.setSpacing(2) + if right: + note_line.addStretch(1) + note_line.addWidget(stem) + note_line.addWidget(stop) + if not right: + note_line.addStretch(1) + col.addLayout(note_line) col.addStretch(1) self.titles[v.name] = title @@ -1282,6 +1309,7 @@ class DjShelf(QWidget): self.sync_buttons[v.name] = sync self.vocal_sliders[v.name] = slider self.stem_labels[v.name] = stem + self.stem_cancel[v.name] = stop holder.setFixedWidth(CONTROLS_WIDTH) self._compact_hidden.append(holder) return holder @@ -1616,6 +1644,7 @@ class DjShelf(QWidget): view.counted = False view.bpm_saved = False view.stem_note = "Loading…" + view.splitting = view.split_called_off = False self.speed[view.name].setValue(0) self.vocal_sliders[view.name].setValue(0) self.set_mult(view, 1.0) @@ -1653,8 +1682,7 @@ class DjShelf(QWidget): self._manager.set_tracks_bpm({view.track.track_id: bpm_detect.fold_bpm(result.bpm)}) view.bpm_saved = True if stems.available(): - view.stem_note = "Vocals: waiting to separate…" - self._splitter.request(view.track.location) + self._request_split(view) else: view.stem_note = "Vocals slider needs Demucs" self.vocal_sliders[view.name].setToolTip( @@ -1673,8 +1701,34 @@ class DjShelf(QWidget): def _views_for(self, path: str): return [v for v in self.views if v.track is not None and v.track.location == path] + def _request_split(self, view: DeckView): + view.stem_note = "Vocals: waiting to separate…" + view.splitting, view.split_called_off = True, False + self._splitter.request(view.track.location) + + def cancel_split(self, view: DeckView): + """The ✕: stop Demucs on this song. Grabbing the vocals slider, or + loading the song again, starts it over.""" + if view.track is not None and view.splitting: + self._splitter.cancel(view.track.location) + + def _retry_split(self, view: DeckView): + if view.split_called_off and view.track is not None and stems.available(): + self._request_split(view) + self._refresh_note(view) + + def _on_stem_cancelled(self, path: str): + for v in self._views_for(path): + if not v.splitting: + continue + v.splitting, v.split_called_off = False, True + v.stem_note = "Vocals split cancelled · grab the slider to retry" + self._refresh_note(v) + def _on_stem_progress(self, path: str, percent: int): for v in self._views_for(path): + if v.split_called_off: + continue v.stem_note = f"Separating vocals… {percent}%" self._refresh_note(v) @@ -1683,6 +1737,7 @@ class DjShelf(QWidget): if not views: return for v in views: + v.splitting = v.split_called_off = False v.stem_note = "Vocals: reading…" self._refresh_note(v) @@ -1707,6 +1762,7 @@ class DjShelf(QWidget): def _on_stem_failed(self, path: str, why: str): for v in self._views_for(path): + v.splitting = False v.stem_note = f"Couldn't separate vocals: {why}" self._refresh_note(v) @@ -1793,8 +1849,10 @@ class DjShelf(QWidget): def _refresh_note(self, view: DeckView): self.stem_labels[view.name].setText(view.stem_note) + self.stem_cancel[view.name].setVisible(view.splitting and view.track is not None) has = view.deck.source is not None and view.deck.source.has_stems() - self.vocal_sliders[view.name].setEnabled(has) + # After a cancel the slider stays live: grabbing it splits again. + self.vocal_sliders[view.name].setEnabled(has or view.split_called_off) def _refresh_deck(self, view: DeckView): deck = view.deck diff --git a/tests/test_round102.py b/tests/test_round102.py new file mode 100644 index 0000000..1553e63 --- /dev/null +++ b/tests/test_round102.py @@ -0,0 +1,91 @@ +"""Round 102: the ✕ that cancels a deck's vocals split.""" +import threading +import time + +from PyQt6.QtWidgets import QApplication + +from lintunes.dj import stems +from tests.test_round93 import _clicks, _loaded, shelf # noqa: F401 — fixture + + +def _wait(predicate, seconds=3.0): + end = time.monotonic() + seconds + while time.monotonic() < end: + QApplication.processEvents() + if predicate(): + return True + time.sleep(0.01) + return False + + +def test_cancelling_the_running_split_stops_demucs(qapp, monkeypatch): + started = threading.Event() + + def fake_split(path, model, gentle, progress=None, cancel=None): + started.set() + while not cancel.wait(0.01): + pass + raise stems.Cancelled() + + monkeypatch.setattr(stems, "cached", lambda path, model=None: None) + monkeypatch.setattr(stems, "split", fake_split) + splitter = stems.StemSplitter() + called_off, done = [], [] + splitter.cancelled.connect(called_off.append) + splitter.finished.connect(lambda p, f: done.append(p)) + splitter.request("/a.mp3") + assert started.wait(2) + splitter.cancel("/a.mp3") + assert _wait(lambda: called_off == ["/a.mp3"]) + assert done == [] + + +def test_cancelling_a_queued_song_takes_it_out(qapp, monkeypatch): + release = threading.Event() + ran = [] + + def fake_split(path, model, gentle, progress=None, cancel=None): + ran.append(path) + release.wait(2) + return {} + + monkeypatch.setattr(stems, "cached", lambda path, model=None: None) + monkeypatch.setattr(stems, "split", fake_split) + splitter = stems.StemSplitter() + called_off = [] + splitter.cancelled.connect(called_off.append) + splitter.request("/a.mp3") + assert _wait(lambda: ran == ["/a.mp3"]) + splitter.request("/b.mp3") + assert _wait(lambda: "/b.mp3" in splitter._queue) + splitter.cancel("/b.mp3") + assert called_off == ["/b.mp3"] and "/b.mp3" not in splitter._queue + release.set() + time.sleep(0.1) + assert ran == ["/a.mp3"] + + +def test_the_x_shows_while_splitting_and_the_slider_retries(shelf, monkeypatch): + from tests.test_round93 import RATE # noqa: F401 + asked, cancelled = [], [] + monkeypatch.setattr(stems, "available", lambda: True) + monkeypatch.setattr(shelf._splitter, "request", asked.append) + monkeypatch.setattr(shelf._splitter, "cancel", cancelled.append) + a, _ = shelf.views + _loaded(shelf, a, shelf.tracks[0], _clicks(124, 0.1, 5), 124.0, 0.1) + x = shelf.stem_cancel["A"] + assert asked == ["/x.mp3"] + assert not x.isHidden() and x.toolTip() == "cancel vocals split" + assert not shelf.vocal_sliders["A"].isEnabled() + x.click() + assert cancelled == ["/x.mp3"] + shelf._on_stem_cancelled("/x.mp3") # what the splitter answers + assert x.isHidden() + assert "cancelled" in shelf.stem_labels["A"].text() + slider = shelf.vocal_sliders["A"] + assert slider.isEnabled() + slider.sliderPressed.emit() + assert asked == ["/x.mp3", "/x.mp3"] + assert not x.isHidden() + slider.sliderPressed.emit() # already splitting: no second ask + assert asked == ["/x.mp3", "/x.mp3"]