b6d78d015d
Completes Phase 1 on top of the backend (43c798a7):
- Cross-source backfill: core/blocklist/backfill.py is a pure injected-resolver
core (resolve only missing sources, never raises); core/blocklist/runtime.py
wires the real metadata clients with a confident name-match (exact
significant-token equality; album/track also require the parent artist when
both expose one — no wrong IDs hung on an entry). Resolution runs
synchronously at add time, so a ban is cross-source from the first scan;
the artist name-fallback in matching covers any gap.
- API: GET/POST/DELETE /api/blocklist (profile-scoped) + /api/blocklist/search
(thin wrapper over the manual-match service search on the active source, so
the modal needn't know the source). Add resolves the other sources before
storing.
- Modal (webui/static/blocklist.js): tabbed Artists/Albums/Tracks in the
revamp design language (accent light-edge, pill tabs, debounced search with
spinner + out-of-order guard, per-result Block, "currently blocked" list
with a match-status star and per-row remove). Opened by a new "Blocklist"
button on the watchlist page, next to Download Origins.
Tests: 5 backfill (fill-missing-only, None/exception handling, arg shape) + 4
API (search proxy, add→backfill→list→delete round trip, validation). Modal
registered in the script-split onclick-coverage test; JS syntax-checked.
50 lines
1.9 KiB
Python
50 lines
1.9 KiB
Python
"""Cross-source ID backfill for blocklist entries.
|
|
|
|
When a user blocks an item, the modal gives us the ID for ONE source (the one
|
|
they searched). For the ban to survive a source switch, we resolve the OTHER
|
|
sources' IDs too — matching the blocked artist/album/track by name on each
|
|
source and taking a confident hit.
|
|
|
|
The resolution is kept pure + injected so it tests without a network: callers
|
|
pass a ``resolvers`` map ``{source: fn(entity_type, name, parent_name) -> id |
|
|
None}``. ``core/blocklist/runtime.py`` wires the real metadata clients.
|
|
|
|
Honest about fragility (acknowledged in design): artist matching is reliable,
|
|
album/track cross-source matching is best-effort (editions, common titles), so
|
|
a resolver returning None just leaves that source unmatched — the artist
|
|
name-fallback in matching.py covers artist gaps; album/track gaps mean that
|
|
ban only applies on sources where an ID resolved.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
from typing import Any, Callable, Dict, Optional
|
|
|
|
from core.blocklist.matching import SOURCE_ID_FIELDS
|
|
|
|
|
|
def resolve_missing_ids(
|
|
entry: Dict[str, Any],
|
|
resolvers: Dict[str, Callable[..., Optional[str]]],
|
|
) -> Dict[str, str]:
|
|
"""Return ``{id_column: resolved_id}`` for the sources currently missing an
|
|
ID on ``entry``. Never raises — a resolver that errors is skipped."""
|
|
out: Dict[str, str] = {}
|
|
entity_type = entry.get("entity_type")
|
|
name = entry.get("name")
|
|
parent = entry.get("parent_name")
|
|
if not entity_type or not name:
|
|
return out
|
|
for source, col in SOURCE_ID_FIELDS.items():
|
|
if entry.get(col):
|
|
continue # already known
|
|
fn = resolvers.get(source)
|
|
if not fn:
|
|
continue
|
|
try:
|
|
rid = fn(entity_type, name, parent)
|
|
except Exception:
|
|
rid = None
|
|
if rid:
|
|
out[col] = str(rid)
|
|
return out
|