v0.71.0: a tiny ✕ cancels a deck's vocals split

This commit is contained in:
2026-10-19 23:04:38 -07:00
parent aea8f82e74
commit 481e6eec9d
5 changed files with 204 additions and 9 deletions
+6 -1
View File
@@ -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×
+1 -1
View File
@@ -1,3 +1,3 @@
"""LinTunes — iTunes-style music library manager and player for Linux."""
__version__ = "0.70.0"
__version__ = "0.71.0"
+44 -3
View File
@@ -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)
+62 -4
View File
@@ -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
+91
View File
@@ -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"]