royalty: modulo check ccMixter + Jamendo con cache SQLite
Nuova feature "Diritti": verifica royalty-free status di brani locali contro DB CC/open (ccMixter sempre attivo, Jamendo opzionale via jamendo_client_id in config). Approccio honest-only: - status 'royalty_free' SOLO con match Levenshtein combinato >= 0.80 - status 'unknown' NON implica automaticamente SIAE (= da verificare) - status 'error' per fingerprint fail / network / tag illeggibili Pipeline: - Scan AUDIO_EXTENSIONS da core.upgrader (ricorsivo opzionale) - Legge artist/title da ID3 (core.metadata.read_metadata), fallback a core.catalog._parse_filename sul nome file - Query parallele ccMixter + Jamendo con throttle 0.3s - Cache SQLite in <config_dir>/royalty_cache.db 21 test verdi (mock requests via responses, cache isolata in tmp_path). Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
lucianoandClaude Opus 4.7 committed
1 parent
9644ffec35
commit
018d310f53
2 files changed
+771
No files matched your search
@@ -0,0 +1,398 @@
|
||||
"""Verifica royalty-free status di brani locali contro DB CC/open.
|
||||
|
||||
Approccio onesto: whitelist royalty-free. L'app segnala un brano come
|
||||
"royalty_free" SOLO se trova un match affidabile in uno dei DB CC/open.
|
||||
"Non trovato" (status 'unknown') NON implica automaticamente SIAE —
|
||||
significa semplicemente "da verificare manualmente".
|
||||
|
||||
Pipeline:
|
||||
1. Scansiona la cartella (filtra per `AUDIO_EXTENSIONS` di
|
||||
`core.upgrader`).
|
||||
2. Per ogni file legge i tag ID3 (artist + title) via
|
||||
`core.metadata.read_metadata`; fallback a
|
||||
`core.catalog._parse_filename` se i tag sono mancanti.
|
||||
3. Query sorgenti royalty-free:
|
||||
- ccMixter (nessuna auth, sempre attivo)
|
||||
- Jamendo (richiede `jamendo_client_id` in config; se vuoto, skip)
|
||||
4. Levenshtein combinato artist+title >= `_SIMILARITY_THRESHOLD` →
|
||||
status 'royalty_free'. Altrimenti 'unknown'.
|
||||
|
||||
Progress callback firma:
|
||||
(processed, total, filename, status[, err_msg])
|
||||
Status: 'checking' | 'stopped' | 'completed' | 'error'.
|
||||
|
||||
`entry_callback(entry)` viene chiamato per ogni file processato
|
||||
(streaming alla UI).
|
||||
"""
|
||||
|
||||
from __future__ import annotations
|
||||
|
||||
import json
|
||||
import sqlite3
|
||||
import threading
|
||||
import time
|
||||
from difflib import SequenceMatcher
|
||||
from pathlib import Path
|
||||
from typing import Callable, Optional
|
||||
|
||||
import requests
|
||||
|
||||
from core.upgrader import AUDIO_EXTENSIONS
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Costanti
|
||||
# ------------------------------------------------------------------
|
||||
_CCMIXTER_URL = "https://ccmixter.org/api/query"
|
||||
_JAMENDO_URL = "https://api.jamendo.com/v3.0/tracks/"
|
||||
_HTTP_TIMEOUT = 15
|
||||
_RATE_LIMIT_SEC = 0.3
|
||||
_SIMILARITY_THRESHOLD = 0.80
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Stop / interrupt
|
||||
# ------------------------------------------------------------------
|
||||
_stop_event = threading.Event()
|
||||
|
||||
|
||||
def request_stop() -> None:
|
||||
"""Segnala al worker di interrompere la scansione al prossimo file."""
|
||||
_stop_event.set()
|
||||
|
||||
|
||||
def reset_stop() -> None:
|
||||
"""Azzera il flag di stop prima di iniziare una nuova scansione."""
|
||||
_stop_event.clear()
|
||||
|
||||
|
||||
def is_stopped() -> bool:
|
||||
return _stop_event.is_set()
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Cache SQLite
|
||||
# ------------------------------------------------------------------
|
||||
def _cache_db_path() -> Path:
|
||||
"""Path del file di cache SQLite (patchable nei test)."""
|
||||
from core.config import _get_config_dir
|
||||
return _get_config_dir() / "royalty_cache.db"
|
||||
|
||||
|
||||
def _init_db(conn: sqlite3.Connection) -> None:
|
||||
conn.executescript(
|
||||
"""
|
||||
CREATE TABLE IF NOT EXISTS lookups(
|
||||
key TEXT PRIMARY KEY,
|
||||
payload TEXT,
|
||||
cached_at REAL
|
||||
);
|
||||
"""
|
||||
)
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Similarity
|
||||
# ------------------------------------------------------------------
|
||||
def _similarity(a: str, b: str) -> float:
|
||||
"""Ritorna SequenceMatcher ratio (0.0 - 1.0) case-insensitive."""
|
||||
if not a or not b:
|
||||
return 0.0
|
||||
return SequenceMatcher(None, a.lower().strip(), b.lower().strip()).ratio()
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Rate limit (globale)
|
||||
# ------------------------------------------------------------------
|
||||
_last_req = [0.0]
|
||||
|
||||
|
||||
def _throttle() -> None:
|
||||
now = time.monotonic()
|
||||
elapsed = now - _last_req[0]
|
||||
if elapsed < _RATE_LIMIT_SEC:
|
||||
time.sleep(_RATE_LIMIT_SEC - elapsed)
|
||||
_last_req[0] = time.monotonic()
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Query sorgenti
|
||||
# ------------------------------------------------------------------
|
||||
def _query_ccmixter(query: str) -> list:
|
||||
"""Query ccMixter API. Ritorna lista di candidati normalizzati."""
|
||||
if not query:
|
||||
return []
|
||||
_throttle()
|
||||
try:
|
||||
resp = requests.get(
|
||||
_CCMIXTER_URL,
|
||||
params={"f": "json", "search": query, "limit": 10},
|
||||
timeout=_HTTP_TIMEOUT,
|
||||
)
|
||||
if resp.status_code != 200:
|
||||
return []
|
||||
data = resp.json()
|
||||
except Exception:
|
||||
return []
|
||||
if not isinstance(data, list):
|
||||
return []
|
||||
out = []
|
||||
for item in data:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
out.append({
|
||||
"source": "ccmixter",
|
||||
"title": item.get("upload_name", "") or "",
|
||||
"artist": (item.get("user_real_name")
|
||||
or item.get("user_name", "")
|
||||
or ""),
|
||||
"license": item.get("license_name", "") or "",
|
||||
"license_url": item.get("license_url", "") or "",
|
||||
"url": item.get("file_page_url", "") or "",
|
||||
})
|
||||
return out
|
||||
|
||||
|
||||
def _query_jamendo(query: str, client_id: str) -> list:
|
||||
"""Query Jamendo API. Senza client_id ritorna []."""
|
||||
if not client_id or not query:
|
||||
return []
|
||||
_throttle()
|
||||
try:
|
||||
resp = requests.get(
|
||||
_JAMENDO_URL,
|
||||
params={
|
||||
"client_id": client_id,
|
||||
"format": "json",
|
||||
"limit": 5,
|
||||
"search": query,
|
||||
},
|
||||
timeout=_HTTP_TIMEOUT,
|
||||
)
|
||||
if resp.status_code != 200:
|
||||
return []
|
||||
data = resp.json()
|
||||
except Exception:
|
||||
return []
|
||||
if not isinstance(data, dict):
|
||||
return []
|
||||
status = (data.get("headers", {}) or {}).get("status", "")
|
||||
if status and status != "success":
|
||||
return []
|
||||
out = []
|
||||
for item in data.get("results", []) or []:
|
||||
if not isinstance(item, dict):
|
||||
continue
|
||||
out.append({
|
||||
"source": "jamendo",
|
||||
"title": item.get("name", "") or "",
|
||||
"artist": item.get("artist_name", "") or "",
|
||||
"license": item.get("license_name") or "Creative Commons",
|
||||
"license_url": item.get("license_ccurl", "") or "",
|
||||
"url": item.get("shareurl", "") or "",
|
||||
})
|
||||
return out
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Check singolo file
|
||||
# ------------------------------------------------------------------
|
||||
def check_file(path: str, jamendo_client_id: str = "") -> dict:
|
||||
"""Verifica un singolo file. Ritorna:
|
||||
{path, status, matches, query, artist, title[, error]}
|
||||
status: 'royalty_free' | 'unknown' | 'error'.
|
||||
"""
|
||||
from core.metadata import read_metadata
|
||||
from core.catalog import _parse_filename
|
||||
|
||||
try:
|
||||
md = read_metadata(path)
|
||||
except Exception as e:
|
||||
return {
|
||||
"path": path,
|
||||
"status": "error",
|
||||
"matches": [],
|
||||
"query": "",
|
||||
"artist": "",
|
||||
"title": "",
|
||||
"error": str(e),
|
||||
}
|
||||
|
||||
artist = (md.get("artist") or "").strip()
|
||||
title = (md.get("title") or "").strip()
|
||||
if not artist or not title:
|
||||
parsed_artist, parsed_title = _parse_filename(Path(path).stem)
|
||||
artist = artist or parsed_artist
|
||||
title = title or parsed_title
|
||||
|
||||
query = f"{artist} {title}".strip() if artist else title
|
||||
if not query:
|
||||
return {
|
||||
"path": path,
|
||||
"status": "unknown",
|
||||
"matches": [],
|
||||
"query": "",
|
||||
"artist": artist,
|
||||
"title": title,
|
||||
"error": "no query (tag + filename vuoti)",
|
||||
}
|
||||
|
||||
# Cache lookup
|
||||
conn = sqlite3.connect(str(_cache_db_path()))
|
||||
try:
|
||||
_init_db(conn)
|
||||
row = conn.execute(
|
||||
"SELECT payload FROM lookups WHERE key=?", (query,)
|
||||
).fetchone()
|
||||
if row:
|
||||
try:
|
||||
cached = json.loads(row[0])
|
||||
cached["path"] = path
|
||||
# Preserva artist/title correnti nel caso siano stati
|
||||
# ricavati dal filename ma la cache li aveva salvati gia'
|
||||
return cached
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
candidates = _query_ccmixter(query)
|
||||
candidates += _query_jamendo(query, jamendo_client_id)
|
||||
|
||||
matches = []
|
||||
for c in candidates:
|
||||
score_title = _similarity(title, c.get("title", ""))
|
||||
score_artist = (
|
||||
_similarity(artist, c.get("artist", ""))
|
||||
if artist and c.get("artist") else 0.0
|
||||
)
|
||||
if artist:
|
||||
combined = score_title * 0.6 + score_artist * 0.4
|
||||
else:
|
||||
combined = score_title
|
||||
if combined >= _SIMILARITY_THRESHOLD:
|
||||
enriched = dict(c)
|
||||
enriched["score"] = round(combined, 2)
|
||||
matches.append(enriched)
|
||||
|
||||
# Ordina per score desc
|
||||
matches.sort(key=lambda m: m.get("score", 0.0), reverse=True)
|
||||
|
||||
status = "royalty_free" if matches else "unknown"
|
||||
result = {
|
||||
"path": path,
|
||||
"status": status,
|
||||
"matches": matches,
|
||||
"query": query,
|
||||
"artist": artist,
|
||||
"title": title,
|
||||
}
|
||||
|
||||
# Scrivi in cache (senza il path, che e' per-file)
|
||||
try:
|
||||
payload = {k: v for k, v in result.items() if k != "path"}
|
||||
conn.execute(
|
||||
"INSERT OR REPLACE INTO lookups(key, payload, cached_at) "
|
||||
"VALUES (?, ?, ?)",
|
||||
(query, json.dumps(payload, ensure_ascii=False), time.time()),
|
||||
)
|
||||
conn.commit()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
return result
|
||||
finally:
|
||||
try:
|
||||
conn.close()
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
# ------------------------------------------------------------------
|
||||
# Scan folder
|
||||
# ------------------------------------------------------------------
|
||||
def _emit_progress(cb: Optional[Callable], idx: int, total: int,
|
||||
name: str, status: str, err: str = "") -> None:
|
||||
"""Chiama progress_callback in modo retrocompatibile (4 o 5 args)."""
|
||||
if not cb:
|
||||
return
|
||||
try:
|
||||
cb(idx, total, name, status, err)
|
||||
except TypeError:
|
||||
try:
|
||||
cb(idx, total, name, status)
|
||||
except Exception:
|
||||
pass
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
|
||||
def scan_folder(
|
||||
directory: str,
|
||||
recursive: bool = True,
|
||||
progress_callback: Optional[Callable] = None,
|
||||
entry_callback: Optional[Callable] = None,
|
||||
) -> list:
|
||||
"""Scansiona la cartella e verifica ogni file audio.
|
||||
|
||||
Ritorna la lista dei risultati per file (vedi `check_file`).
|
||||
`entry_callback(entry)` e' chiamato appena ogni file e' processato.
|
||||
"""
|
||||
reset_stop()
|
||||
base = Path(directory)
|
||||
if not base.exists() or not base.is_dir():
|
||||
_emit_progress(progress_callback, 0, 0, "", "completed", "")
|
||||
return []
|
||||
|
||||
files: list = []
|
||||
iterator = base.rglob("*") if recursive else base.iterdir()
|
||||
for f in iterator:
|
||||
try:
|
||||
if f.is_file() and f.suffix.lower() in AUDIO_EXTENSIONS:
|
||||
files.append(f)
|
||||
except OSError:
|
||||
continue
|
||||
files.sort()
|
||||
total = len(files)
|
||||
|
||||
if total == 0:
|
||||
_emit_progress(progress_callback, 0, 0, "", "completed", "")
|
||||
return []
|
||||
|
||||
# Jamendo client_id (opzionale)
|
||||
jamendo_id = ""
|
||||
try:
|
||||
from core.config import load_config
|
||||
jamendo_id = (load_config().get("jamendo_client_id") or "").strip()
|
||||
except Exception:
|
||||
jamendo_id = ""
|
||||
|
||||
results: list = []
|
||||
for i, fp in enumerate(files, start=1):
|
||||
if is_stopped():
|
||||
_emit_progress(progress_callback, i - 1, total, "", "stopped", "")
|
||||
return results
|
||||
|
||||
_emit_progress(progress_callback, i, total, fp.name, "checking", "")
|
||||
try:
|
||||
r = check_file(str(fp), jamendo_client_id=jamendo_id)
|
||||
except Exception as e:
|
||||
r = {
|
||||
"path": str(fp),
|
||||
"status": "error",
|
||||
"matches": [],
|
||||
"query": "",
|
||||
"artist": "",
|
||||
"title": "",
|
||||
"error": str(e),
|
||||
}
|
||||
_emit_progress(progress_callback, i, total, fp.name, "error", str(e))
|
||||
|
||||
results.append(r)
|
||||
if entry_callback:
|
||||
try:
|
||||
entry_callback(r)
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
if not is_stopped():
|
||||
_emit_progress(progress_callback, total, total, "", "completed", "")
|
||||
return results
|
||||
Reference in new issue
Block a user