v0.71.0: a tiny ✕ cancels a deck's vocals split
This commit is contained in:
@@ -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,3 +1,3 @@
|
||||
"""LinTunes — iTunes-style music library manager and player for Linux."""
|
||||
|
||||
__version__ = "0.70.0"
|
||||
__version__ = "0.71.0"
|
||||
|
||||
+44
-3
@@ -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)
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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"]
|
||||
Reference in New Issue
Block a user