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

1"""Delete library files and playlists (disk, catalog, caches).""" 

2 

3from __future__ import annotations 

4 

5from dataclasses import dataclass 

6from pathlib import Path 

7from typing import Any, Optional 

8 

9from loguru import logger 

10 

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) 

32 

33 

34@dataclass 

35class TagMismatchDeleteContext: 

36 """Optional caches/indexes used when removing wrong on-disk audio.""" 

37 

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 

48 

49 

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*. 

54 

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).""" 

58 

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 ) 

78 

79 

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. 

87 

88 Returns ``True`` when the file was removed from disk and catalog. 

89 """ 

90 

91 if not song.get('library_from_tags'): 

92 return False 

93 if spotify_aligns_with_file_tags(song): 

94 return False 

95 

96 filename = str(song.get('filename') or '').strip().replace('\\', '/') 

97 if not filename: 

98 return False 

99 

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 

120 

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 

129 

130 

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.""" 

138 

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 ) 

165 

166 

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 ) 

179 

180 

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.""" 

193 

194 file_key = str(stored_path or '').strip().replace('\\', '/') 

195 if not file_key: 

196 return {'file': stored_path, 'deleted': False, 'error': 'Empty path'} 

197 

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 } 

206 

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) 

222 

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) 

242 

243 if invalidate_paths: 

244 drop_library_listing_files(ctx, [file_key]) 

245 invalidate_library_paths_cache() 

246 

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 } 

263 

264 

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.""" 

273 

274 seen: set[str] = set() 

275 deleted: list[str] = [] 

276 failed: list[dict[str, str]] = [] 

277 affected: set[str] = set() 

278 

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 }) 

303 

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 } 

326 

327 

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 

352 

353 

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*.""" 

362 

363 deleted: list[str] = [] 

364 failed: list[dict[str, str]] = [] 

365 affected: set[str] = set() 

366 

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 } 

395 

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 }) 

428 

429 return { 

430 'deleted': deleted, 

431 'failed': failed, 

432 'playlists_affected': sorted(affected), 

433 } 

434 

435 

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 

457 

458 

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. 

466 

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 

491 

492 

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 ) 

527 

528 

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 ) 

548 

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 

562 

563 

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 ) 

608 

609 

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)} 

622 

623 

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).""" 

632 

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} 

643 

644 

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.""" 

652 

653 pl_name = str(playlist_name or '').strip() 

654 if not pl_name: 

655 return {'ok': False, 'error': 'Empty playlist name'} 

656 

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) 

688 

689 

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]: 

697 

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 ) 

712 

713 catalog = state.playlist_catalog 

714 if catalog is None: 

715 return {'ok': False, 'error': 'Playlist catalog not available'} 

716 

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] = [] 

722 

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 ) 

743 

744 m3u_removed = _remove_playlist_m3u_files( 

745 download_dir, 

746 pl_name, 

747 organize_by_artist=organize, 

748 ) 

749 

750 affected.add(pl_name) 

751 if deleted: 

752 drop_library_listing_files(ctx, deleted) 

753 invalidate_library_paths_cache() 

754 

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 ) 

767 

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 }