Coverage for downtify/library_delete.py: 79%
268 statements
« prev ^ index » next coverage.py v7.17.4, created at 2026-11-21 22:18 +0000
« prev ^ index » next coverage.py v7.17.4, created at 2026-11-21 22:18 +0000
1"""Delete library files and playlists (disk, catalog, caches)."""
3from __future__ import annotations
5from dataclasses import dataclass
6from pathlib import Path
7from typing import Any, Optional
9from loguru import logger
11from .download_sources import track_keys
12from .library_catalog import (
13 AUDIO_EXTENSIONS,
14 PODCASTS_DIRNAME,
15 LibraryContext,
16 drop_library_listing_files,
17 library_context_from_state,
18 resolve_library_file,
19)
20from .library_cleanup import prune_empty_parent_dirs, remove_track_leftovers
21from .library_paths import library_file_root, library_stored_path
22from .library_paths_cache import invalidate_library_paths_cache
23from .m3u import find_m3u_for_name, is_manual_m3u, sanitize_playlist_name
24from .manual_playlists import (
25 drop_manual_playlist,
26 prune_files_from_manual_playlists,
27)
28from .track_tag_match import (
29 spotify_aligns_with_file_tags,
30 spotify_file_tag_mismatch_label,
31)
34@dataclass
35class TagMismatchDeleteContext:
36 """Optional caches/indexes used when removing wrong on-disk audio."""
38 ctx: LibraryContext
39 cover_cache: Any = None
40 metadata_cache: Any = None
41 playlist_catalog: Any = None
42 track_index: Any = None
43 navidrome_index: Any = None
44 # Where each file's audio came from (downtify.download_sources): the
45 # upload of a wrong file is rejected for its song, so the next
46 # download of it picks another one.
47 download_sources: Any = None
50def _reject_wrong_upload(
51 filename: str, song: dict[str, Any], sources: Any
52) -> None:
53 """Never pick the upload *filename* came from again for *song*.
55 Without it, a playlist refresh deletes the wrong file, the monitor
56 forgets the track, the next sweep fetches the very same upload, and
57 the cycle repeats on every sweep (issue #573)."""
59 if sources is None:
60 return
61 spotify_song = {
62 'song_id': song.get('song_id'),
63 'source': song.get('source'),
64 'isrc': song.get('isrc'),
65 'name': song.get('spotify_name') or song.get('name'),
66 'artists': song.get('spotify_artists') or song.get('artists'),
67 }
68 try:
69 sources.reject_file_source(
70 filename,
71 track_keys(spotify_song),
72 why='its tags do not match the playlist track',
73 )
74 except Exception:
75 logger.opt(exception=True).debug(
76 'Could not reject the upload of {}', filename
77 )
80def delete_if_spotify_tag_mismatch(
81 song: dict[str, Any],
82 del_ctx: TagMismatchDeleteContext,
83 *,
84 playlist_name: str = '',
85) -> bool:
86 """Delete a library file whose embedded tags disagree with Spotify.
88 Returns ``True`` when the file was removed from disk and catalog.
89 """
91 if not song.get('library_from_tags'):
92 return False
93 if spotify_aligns_with_file_tags(song):
94 return False
96 filename = str(song.get('filename') or '').strip().replace('\\', '/')
97 if not filename:
98 return False
100 label = spotify_file_tag_mismatch_label(song)
101 pl_note = f' playlist={playlist_name!r}' if playlist_name else ''
102 _reject_wrong_upload(filename, song, del_ctx.download_sources)
103 result = delete_library_file(
104 filename,
105 del_ctx.ctx,
106 cover_cache=del_ctx.cover_cache,
107 metadata_cache=del_ctx.metadata_cache,
108 playlist_catalog=del_ctx.playlist_catalog,
109 track_index=del_ctx.track_index,
110 navidrome_index=del_ctx.navidrome_index,
111 )
112 if result.get('deleted'):
113 logger.info(
114 'library: deleted wrong file {} ({}){}',
115 filename,
116 label,
117 pl_note,
118 )
119 return True
121 logger.warning(
122 'library: tag mismatch but delete failed for {} ({}){} — {}',
123 filename,
124 label,
125 pl_note,
126 result.get('error') or 'unknown error',
127 )
128 return False
131def tag_mismatch_delete_context_from_state(
132 state: Any,
133 *,
134 download_dir: Optional[Path] = None,
135 settings: Optional[dict[str, Any]] = None,
136) -> Optional[TagMismatchDeleteContext]:
137 """Build delete context from app ``state`` when a downloader is configured."""
139 downloader = getattr(state, 'downloader', None)
140 if downloader is None:
141 return None
142 dl_dir = download_dir or Path(downloader.download_dir)
143 cfg = (
144 settings
145 if isinstance(settings, dict)
146 else getattr(state, 'settings', {})
147 )
148 if not isinstance(cfg, dict):
149 cfg = {}
150 return TagMismatchDeleteContext(
151 ctx=library_context_from_state(
152 dl_dir,
153 cfg,
154 track_index=getattr(state, 'track_index', None),
155 metadata_cache=getattr(state, 'metadata_cache', None),
156 playlist_catalog=getattr(state, 'playlist_catalog', None),
157 ),
158 cover_cache=getattr(state, 'cover_cache', None),
159 metadata_cache=getattr(state, 'metadata_cache', None),
160 playlist_catalog=getattr(state, 'playlist_catalog', None),
161 track_index=getattr(state, 'track_index', None),
162 navidrome_index=getattr(state, 'navidrome_index', None),
163 download_sources=getattr(state, 'download_sources', None),
164 )
167def _log_failed_deletes(
168 failed: list[dict[str, str]],
169 *,
170 context: str,
171) -> None:
172 for item in failed:
173 logger.warning(
174 '{}: could not delete {} — {}',
175 context,
176 item.get('file') or '?',
177 item.get('error') or 'unknown error',
178 )
181def delete_library_file(
182 stored_path: str,
183 ctx: LibraryContext,
184 *,
185 cover_cache: Any = None,
186 metadata_cache: Any = None,
187 playlist_catalog: Any = None,
188 track_index: Any = None,
189 navidrome_index: Any = None,
190 invalidate_paths: bool = True,
191) -> dict[str, Any]:
192 """Remove one library file and catalog rows. Does not refresh playlists."""
194 file_key = str(stored_path or '').strip().replace('\\', '/')
195 if not file_key:
196 return {'file': stored_path, 'deleted': False, 'error': 'Empty path'}
198 full = resolve_library_file(file_key, ctx)
199 if full is None:
200 logger.warning('Library delete: file not found on disk: {}', file_key)
201 return {
202 'file': file_key,
203 'deleted': False,
204 'error': 'File not found',
205 }
207 try:
208 full.unlink()
209 except OSError as exc:
210 logger.warning(
211 'Library delete: could not unlink {}: {}',
212 full,
213 exc,
214 )
215 return {'file': file_key, 'deleted': False, 'error': str(exc)}
216 # Same leftovers DELETE /delete removes: .lrc sidecar, orphaned
217 # cover.jpg, and folders left empty (never the library roots).
218 root, _rel = library_file_root(
219 file_key, ctx.download_dir, ctx.slskd_dir, ctx.extra_dirs
220 )
221 remove_track_leftovers(full, root)
223 affected_playlists: list[str] = []
224 if cover_cache is not None:
225 cover_cache.forget(file_key, full_path=full)
226 if metadata_cache is not None:
227 metadata_cache.forget(file_key, full_path=full)
228 if playlist_catalog is not None:
229 affected_playlists = playlist_catalog.remove_tracks_for_filename(
230 file_key
231 )
232 affected_playlists = list(
233 dict.fromkeys(
234 list(affected_playlists)
235 + prune_files_from_manual_playlists(ctx, [file_key])
236 )
237 )
238 if track_index is not None:
239 track_index.remove_by_filename(file_key)
240 if navidrome_index is not None:
241 navidrome_index.forget_filename(file_key, full_path=full)
243 if invalidate_paths:
244 drop_library_listing_files(ctx, [file_key])
245 invalidate_library_paths_cache()
247 if affected_playlists:
248 logger.info(
249 'Library delete: removed {} (playlists: {})',
250 file_key,
251 ', '.join(affected_playlists),
252 )
253 else:
254 logger.info(
255 'Library delete: removed {} (not linked to a playlist in catalog)',
256 file_key,
257 )
258 return {
259 'file': file_key,
260 'deleted': True,
261 'playlists_affected': affected_playlists,
262 }
265def delete_library_files(
266 stored_paths: list[str],
267 ctx: LibraryContext,
268 state: Any,
269 *,
270 log_failures: bool = True,
271) -> dict[str, Any]:
272 """Delete many files; return per-file results and union of affected playlists."""
274 seen: set[str] = set()
275 deleted: list[str] = []
276 failed: list[dict[str, str]] = []
277 affected: set[str] = set()
279 for raw in stored_paths:
280 key = str(raw or '').strip().replace('\\', '/')
281 if not key or key in seen:
282 continue
283 seen.add(key)
284 result = delete_library_file(
285 key,
286 ctx,
287 cover_cache=state.cover_cache,
288 metadata_cache=state.metadata_cache,
289 playlist_catalog=state.playlist_catalog,
290 track_index=state.track_index,
291 navidrome_index=state.navidrome_index,
292 invalidate_paths=False,
293 )
294 if result.get('deleted'):
295 deleted.append(key)
296 for pl in result.get('playlists_affected') or []:
297 affected.add(str(pl))
298 else:
299 failed.append({
300 'file': key,
301 'error': str(result.get('error') or 'Delete failed'),
302 })
304 if deleted:
305 drop_library_listing_files(ctx, deleted)
306 invalidate_library_paths_cache()
307 pl_note = (
308 f'; playlists: {", ".join(sorted(affected))}'
309 if affected
310 else '; no playlist catalog links'
311 )
312 logger.info(
313 'Batch library delete: removed {} file(s){}',
314 len(deleted),
315 pl_note,
316 )
317 if failed and log_failures:
318 _log_failed_deletes(failed, context='Batch library delete')
319 return {
320 'deleted': deleted,
321 'failed': failed,
322 'deleted_count': len(deleted),
323 'failed_count': len(failed),
324 'playlists_affected': sorted(affected),
325 }
328def _m3u_paths_for_playlist(
329 download_dir: Path,
330 playlist_name: str,
331 *,
332 organize_by_artist: bool,
333) -> list[Path]:
334 safe = sanitize_playlist_name(playlist_name)
335 paths = [
336 download_dir / 'Playlists' / f'{safe}.m3u',
337 download_dir / safe / f'{safe}.m3u',
338 ]
339 if organize_by_artist:
340 paths = paths[:1]
341 # Keep canonical candidates for cover cleanup even without an M3U.
342 for directory in {path.parent for path in paths}:
343 try:
344 paths.extend(
345 path
346 for path in directory.iterdir()
347 if path.stem == safe and path.suffix.lower() == '.m3u8'
348 )
349 except OSError:
350 continue
351 return paths
354def _delete_audio_under_dir(
355 directory: Path,
356 ctx: LibraryContext,
357 state: Any,
358 *,
359 skip_paths: set[str],
360) -> dict[str, Any]:
361 """Delete audio files under *directory* not already in *skip_paths*."""
363 deleted: list[str] = []
364 failed: list[dict[str, str]] = []
365 affected: set[str] = set()
367 if not directory.is_dir():
368 logger.debug(
369 'Playlist folder scan: directory does not exist: {}',
370 directory,
371 )
372 return {
373 'deleted': deleted,
374 'failed': failed,
375 'playlists_affected': [],
376 }
377 try:
378 podcasts_root = (ctx.download_dir / PODCASTS_DIRNAME).resolve()
379 is_podcasts_root = directory.resolve() == podcasts_root
380 except OSError:
381 is_podcasts_root = False
382 if is_podcasts_root:
383 # A playlist named "Podcasts" would otherwise sweep every show's
384 # episodes at once — playlists and podcast subscriptions are
385 # deleted through entirely different paths on purpose.
386 logger.warning(
387 'Refusing to sweep the Podcasts folder as a playlist folder: {}',
388 directory,
389 )
390 return {
391 'deleted': deleted,
392 'failed': failed,
393 'playlists_affected': [],
394 }
396 logger.debug('Playlist folder scan: {}', directory)
397 # Materialized up front: deleting a track can prune its folder.
398 for path in list(directory.rglob('*')):
399 if not path.is_file():
400 continue
401 if path.suffix.lower() not in AUDIO_EXTENSIONS:
402 continue
403 stored = library_stored_path(
404 path, ctx.download_dir, ctx.slskd_dir, ctx.extra_dirs
405 )
406 if stored in skip_paths:
407 continue
408 result = delete_library_file(
409 stored,
410 ctx,
411 cover_cache=state.cover_cache,
412 metadata_cache=state.metadata_cache,
413 playlist_catalog=state.playlist_catalog,
414 track_index=state.track_index,
415 navidrome_index=state.navidrome_index,
416 invalidate_paths=False,
417 )
418 if result.get('deleted'):
419 deleted.append(stored)
420 skip_paths.add(stored)
421 for pl in result.get('playlists_affected') or []:
422 affected.add(str(pl))
423 else:
424 failed.append({
425 'file': stored,
426 'error': str(result.get('error') or 'Delete failed'),
427 })
429 return {
430 'deleted': deleted,
431 'failed': failed,
432 'playlists_affected': sorted(affected),
433 }
436def _remove_playlist_m3u_files(
437 download_dir: Path,
438 playlist_name: str,
439 *,
440 organize_by_artist: bool,
441) -> int:
442 removed = 0
443 for m3u_path in _m3u_paths_for_playlist(
444 download_dir,
445 playlist_name,
446 organize_by_artist=organize_by_artist,
447 ):
448 try:
449 if m3u_path.is_file():
450 m3u_path.unlink()
451 removed += 1
452 logger.info('Playlist delete: removed M3U {}', m3u_path)
453 prune_empty_parent_dirs(m3u_path.parent, download_dir)
454 except OSError as exc:
455 logger.warning('Could not remove M3U {}: {}', m3u_path, exc)
456 return removed
459def _remove_playlist_cover_file(
460 download_dir: Path,
461 playlist_name: str,
462 *,
463 organize_by_artist: bool,
464) -> bool:
465 """Remove the playlist's cover art, if any.
467 Saved by ``downloader.save_playlist_cover`` at the same path as the
468 playlist's M3U, with a ``.jpg`` suffix instead — see
469 ``_m3u_paths_for_playlist`` for the candidate locations. Returns
470 whether a file was removed.
471 """
472 for m3u_path in _m3u_paths_for_playlist(
473 download_dir,
474 playlist_name,
475 organize_by_artist=organize_by_artist,
476 ):
477 cover_path = m3u_path.with_suffix('.jpg')
478 try:
479 if cover_path.is_file():
480 cover_path.unlink()
481 logger.info(
482 'Playlist delete: removed cover art {}', cover_path
483 )
484 prune_empty_parent_dirs(cover_path.parent, download_dir)
485 return True
486 except OSError as exc:
487 logger.warning(
488 'Could not remove cover art {}: {}', cover_path, exc
489 )
490 return False
493def _log_playlist_delete_summary(
494 playlist_name: str,
495 *,
496 catalog_count: int,
497 deleted_count: int,
498 catalog_deleted: int,
499 folder_deleted: int,
500 failed_count: int,
501 m3u_removed: int,
502 cover_removed: bool,
503) -> None:
504 if deleted_count:
505 logger.info(
506 'Playlist delete finished for {!r}: {} audio file(s) removed '
507 '({} from catalog, {} from folder scan), {} failed, {} M3U '
508 'file(s), cover removed={}',
509 playlist_name,
510 deleted_count,
511 catalog_deleted,
512 folder_deleted,
513 failed_count,
514 m3u_removed,
515 cover_removed,
516 )
517 return
518 logger.warning(
519 'Playlist delete finished for {!r}: no audio files removed from disk '
520 '(catalog listed {}, failed {}, M3U removed {}, cover removed={})',
521 playlist_name,
522 catalog_count,
523 failed_count,
524 m3u_removed,
525 cover_removed,
526 )
529def _delete_playlist_catalog_tracks(
530 playlist_name: str,
531 ctx: LibraryContext,
532 state: Any,
533 catalog: Any,
534) -> tuple[list[str], list[str], list[dict[str, str]], set[str], set[str]]:
535 filenames = catalog.delete_playlist(playlist_name)
536 seen = set(filenames)
537 logger.info(
538 'Playlist delete: catalog had {} registered track file(s) for {!r}',
539 len(filenames),
540 playlist_name,
541 )
542 if not filenames:
543 logger.info(
544 'Playlist delete: no catalog entries for {!r}; '
545 'relying on folder scan and M3U cleanup',
546 playlist_name,
547 )
549 batch = delete_library_files(list(seen), ctx, state, log_failures=False)
550 downloaded_from_catalog = list(batch['deleted'])
551 failed = list(batch['failed'])
552 if filenames:
553 logger.info(
554 'Playlist delete: removed {}/{} catalog track file(s) for {!r}',
555 len(downloaded_from_catalog),
556 len(filenames),
557 playlist_name,
558 )
559 _log_failed_deletes(failed, context=f'Playlist delete ({playlist_name!r})')
560 affected = set(batch.get('playlists_affected') or [])
561 return filenames, downloaded_from_catalog, failed, seen, affected
564def _delete_playlist_folder_extras(
565 playlist_name: str,
566 playlist_dir: Path,
567 ctx: LibraryContext,
568 state: Any,
569 *,
570 skip_paths: set[str],
571 already_deleted: list[str],
572) -> tuple[list[str], list[dict[str, str]], list[str], list[str]]:
573 extra = _delete_audio_under_dir(
574 playlist_dir,
575 ctx,
576 state,
577 skip_paths=skip_paths,
578 )
579 extra_deleted = [
580 fn for fn in extra['deleted'] if fn not in already_deleted
581 ]
582 merged = list(already_deleted)
583 for fn in extra['deleted']:
584 if fn not in merged:
585 merged.append(fn)
586 if extra_deleted:
587 logger.info(
588 'Playlist delete: removed {} extra track file(s) from {}',
589 len(extra_deleted),
590 playlist_dir,
591 )
592 elif playlist_dir.is_dir():
593 logger.info(
594 'Playlist delete: no extra audio under {} '
595 '(folder exists, nothing beyond catalog list)',
596 playlist_dir,
597 )
598 _log_failed_deletes(
599 extra['failed'],
600 context=f'Playlist delete folder scan ({playlist_name!r})',
601 )
602 return (
603 merged,
604 extra['failed'],
605 extra_deleted,
606 list(extra.get('playlists_affected') or []),
607 )
610def _drop_manual_playlist_if_any(
611 ctx: LibraryContext,
612 download_dir: Path,
613 playlist_name: str,
614) -> Optional[dict[str, Any]]:
615 found = find_m3u_for_name(download_dir, playlist_name)
616 if found is None or not is_manual_m3u(found):
617 return None
618 try:
619 return drop_manual_playlist(ctx, found.stem)
620 except Exception as exc:
621 return {'ok': False, 'error': str(exc)}
624def remove_playlist_shell(
625 playlist_name: str,
626 download_dir: Path,
627 *,
628 organize_by_artist: bool = False,
629) -> dict[str, Any]:
630 """Remove a playlist's M3U file(s) and sidecar cover; audio and the
631 catalog entry are left alone (the caller handles those)."""
633 pl_name = str(playlist_name or '').strip()
634 if not pl_name:
635 return {'m3u_removed': 0, 'cover_removed': False}
636 m3u_removed = _remove_playlist_m3u_files(
637 download_dir, pl_name, organize_by_artist=organize_by_artist
638 )
639 cover_removed = _remove_playlist_cover_file(
640 download_dir, pl_name, organize_by_artist=organize_by_artist
641 )
642 return {'m3u_removed': m3u_removed, 'cover_removed': cover_removed}
645def delete_playlist_from_library(
646 playlist_name: str,
647 download_dir: Path,
648 settings: dict[str, Any],
649 state: Any,
650) -> dict[str, Any]:
651 """Delete all tracks for a playlist, remove M3U, drop catalog entry."""
653 pl_name = str(playlist_name or '').strip()
654 if not pl_name:
655 return {'ok': False, 'error': 'Empty playlist name'}
657 ctx = library_context_from_state(
658 download_dir,
659 settings,
660 track_index=state.track_index,
661 )
662 if getattr(state, 'library_trash', None) is not None:
663 manual = _drop_manual_playlist_if_any(ctx, download_dir, pl_name)
664 if manual is not None:
665 return manual
666 if state.playlist_catalog is not None:
667 state.playlist_catalog.delete_playlist(pl_name)
668 remove_playlist_shell(
669 pl_name,
670 download_dir,
671 organize_by_artist=bool(
672 settings.get('organize_by_artist')
673 or settings.get('organize_by_album')
674 ),
675 )
676 return {
677 'ok': True,
678 'playlist': pl_name,
679 'files': [],
680 'deleted_count': 0,
681 'failed_count': 0,
682 'failed': [],
683 'playlists_affected': [pl_name],
684 }
685 return _drop_manual_playlist_if_any(
686 ctx, download_dir, pl_name
687 ) or _delete_imported_playlist(pl_name, download_dir, settings, state, ctx)
690def _delete_imported_playlist(
691 pl_name: str,
692 download_dir: Path,
693 settings: dict[str, Any],
694 state: Any,
695 ctx: LibraryContext,
696) -> dict[str, Any]:
698 # With organize-by-artist or -album on, tracks live in artist/album
699 # folders, not a per-playlist folder — and a same-named album folder
700 # must not be swept as if it were the playlist's.
701 organize = bool(
702 settings.get('organize_by_artist', False)
703 or settings.get('organize_by_album', False)
704 )
705 safe = sanitize_playlist_name(pl_name)
706 logger.info(
707 'Deleting playlist {!r} (folder={!r}, organized={})',
708 pl_name,
709 safe,
710 organize,
711 )
713 catalog = state.playlist_catalog
714 if catalog is None:
715 return {'ok': False, 'error': 'Playlist catalog not available'}
717 filenames, downloaded_from_catalog, failed, seen, affected = (
718 _delete_playlist_catalog_tracks(pl_name, ctx, state, catalog)
719 )
720 deleted = list(downloaded_from_catalog)
721 extra_deleted: list[str] = []
723 if not organize:
724 deleted, extra_failed, extra_deleted, extra_affected = (
725 _delete_playlist_folder_extras(
726 pl_name,
727 download_dir / safe,
728 ctx,
729 state,
730 skip_paths=seen,
731 already_deleted=downloaded_from_catalog,
732 )
733 )
734 failed.extend(extra_failed)
735 for pl_name_affected in extra_affected:
736 affected.add(pl_name_affected)
737 else:
738 logger.info(
739 'Playlist delete: skipped folder scan for {!r} '
740 '(organize by artist/album enabled)',
741 pl_name,
742 )
744 m3u_removed = _remove_playlist_m3u_files(
745 download_dir,
746 pl_name,
747 organize_by_artist=organize,
748 )
750 affected.add(pl_name)
751 if deleted:
752 drop_library_listing_files(ctx, deleted)
753 invalidate_library_paths_cache()
755 _log_playlist_delete_summary(
756 pl_name,
757 catalog_count=len(filenames),
758 deleted_count=len(deleted),
759 catalog_deleted=len(downloaded_from_catalog),
760 folder_deleted=len(extra_deleted),
761 failed_count=len(failed),
762 m3u_removed=m3u_removed,
763 cover_removed=_remove_playlist_cover_file(
764 download_dir, pl_name, organize_by_artist=organize
765 ),
766 )
768 return {
769 'ok': True,
770 'playlist': pl_name,
771 'files': deleted,
772 'deleted_count': len(deleted),
773 'failed_count': len(failed),
774 'failed': failed,
775 'playlists_affected': sorted(affected),
776 }