data
37dff4de69
Projekt aus Docker-Image videoconverter:2.9 extrahiert. Enthält zweiphasigen Import-Workflow mit Serien-Zuordnung. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
1033 lines
38 KiB
Python
1033 lines
38 KiB
Python
"""TheTVDB API v4 Integration fuer Serien-Metadaten"""
|
|
import logging
|
|
import os
|
|
from typing import Optional, TYPE_CHECKING
|
|
|
|
import aiohttp
|
|
import aiomysql
|
|
|
|
from app.config import Config
|
|
|
|
if TYPE_CHECKING:
|
|
from app.services.library import LibraryService
|
|
|
|
# tvdb-v4-official ist optional - funktioniert auch ohne
|
|
try:
|
|
import tvdb_v4_official
|
|
TVDB_AVAILABLE = True
|
|
except ImportError:
|
|
TVDB_AVAILABLE = False
|
|
logging.warning("tvdb-v4-official nicht installiert - TVDB deaktiviert")
|
|
|
|
# Artwork-Typ-IDs -> Namen
|
|
ARTWORK_TYPE_MAP = {
|
|
1: "banner",
|
|
2: "poster",
|
|
3: "fanart",
|
|
5: "icon",
|
|
6: "season_poster",
|
|
7: "season_banner",
|
|
22: "clearlogo",
|
|
23: "clearart",
|
|
}
|
|
|
|
|
|
class TVDBService:
|
|
"""TVDB API v4 Client fuer Serien- und Film-Metadaten"""
|
|
|
|
def __init__(self, config: Config):
|
|
self.config = config
|
|
self._client = None
|
|
self._db_pool: Optional[aiomysql.Pool] = None
|
|
|
|
@property
|
|
def _api_key(self) -> str:
|
|
return self.config.settings.get("library", {}).get("tvdb_api_key", "")
|
|
|
|
@property
|
|
def _pin(self) -> str:
|
|
return self.config.settings.get("library", {}).get("tvdb_pin", "")
|
|
|
|
@property
|
|
def _language(self) -> str:
|
|
"""Konfigurierte TVDB-Sprache (Standard: deu)"""
|
|
return self.config.settings.get("library", {}).get(
|
|
"tvdb_language", "deu"
|
|
)
|
|
|
|
@property
|
|
def is_configured(self) -> bool:
|
|
return TVDB_AVAILABLE and bool(self._api_key)
|
|
|
|
def set_db_pool(self, pool: aiomysql.Pool) -> None:
|
|
"""Setzt den DB-Pool (geteilt mit LibraryService)"""
|
|
self._db_pool = pool
|
|
|
|
def _get_client(self):
|
|
"""Erstellt oder gibt TVDB-Client zurueck"""
|
|
if not TVDB_AVAILABLE:
|
|
return None
|
|
if not self._api_key:
|
|
return None
|
|
|
|
if self._client is None:
|
|
try:
|
|
if self._pin:
|
|
self._client = tvdb_v4_official.TVDB(
|
|
self._api_key, pin=self._pin
|
|
)
|
|
else:
|
|
self._client = tvdb_v4_official.TVDB(self._api_key)
|
|
logging.info("TVDB Client verbunden")
|
|
except Exception as e:
|
|
logging.error(f"TVDB Verbindung fehlgeschlagen: {e}")
|
|
return None
|
|
|
|
return self._client
|
|
|
|
# === DB-Tabellen ===
|
|
|
|
async def init_db(self) -> None:
|
|
"""Erstellt TVDB-Cache-Tabellen"""
|
|
if not self._db_pool:
|
|
return
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute("""
|
|
CREATE TABLE IF NOT EXISTS tvdb_cast_cache (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
series_tvdb_id INT NOT NULL,
|
|
person_name VARCHAR(256) NOT NULL,
|
|
character_name VARCHAR(256),
|
|
sort_order INT DEFAULT 0,
|
|
image_url VARCHAR(512),
|
|
person_image_url VARCHAR(512),
|
|
cached_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
INDEX idx_series (series_tvdb_id)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
""")
|
|
|
|
await cur.execute("""
|
|
CREATE TABLE IF NOT EXISTS tvdb_artwork_cache (
|
|
id INT AUTO_INCREMENT PRIMARY KEY,
|
|
series_tvdb_id INT NOT NULL,
|
|
artwork_type VARCHAR(32) NOT NULL,
|
|
image_url VARCHAR(512) NOT NULL,
|
|
thumbnail_url VARCHAR(512),
|
|
width INT DEFAULT 0,
|
|
height INT DEFAULT 0,
|
|
is_primary TINYINT DEFAULT 0,
|
|
local_path VARCHAR(1024) NULL,
|
|
cached_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
INDEX idx_series (series_tvdb_id),
|
|
INDEX idx_type (artwork_type)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4
|
|
""")
|
|
|
|
# Neue Spalten in library_series (falls noch nicht vorhanden)
|
|
try:
|
|
await cur.execute(
|
|
"ALTER TABLE library_series "
|
|
"ADD COLUMN metadata_path VARCHAR(1024) NULL"
|
|
)
|
|
except Exception:
|
|
pass # Spalte existiert bereits
|
|
try:
|
|
await cur.execute(
|
|
"ALTER TABLE library_series "
|
|
"ADD COLUMN genres VARCHAR(512) NULL"
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
logging.info("TVDB-Cache-Tabellen initialisiert")
|
|
except Exception as e:
|
|
logging.error(f"TVDB-Tabellen erstellen fehlgeschlagen: {e}")
|
|
|
|
@staticmethod
|
|
def _serialize_row(row: dict) -> dict:
|
|
"""DB-Row JSON-kompatibel machen (datetime -> str)"""
|
|
result = {}
|
|
for k, v in row.items():
|
|
if hasattr(v, "isoformat"):
|
|
result[k] = str(v)
|
|
else:
|
|
result[k] = v
|
|
return result
|
|
|
|
# === Suche ===
|
|
|
|
def _localize_search_result(self, item: dict) -> tuple[str, str]:
|
|
"""Lokalisierten Namen + Overview aus Suchergebnis extrahieren.
|
|
Nutzt konfigurierte Sprache, Fallback auf Englisch."""
|
|
lang = self._language
|
|
name = item.get("name", "")
|
|
overview = item.get("overview", "")
|
|
|
|
# translations = {"deu": "Deutscher Titel", "eng": "English", ...}
|
|
trans = item.get("translations") or {}
|
|
if isinstance(trans, dict):
|
|
name = trans.get(lang) or name
|
|
|
|
# overviews = {"deu": "Deutsche Beschreibung", "eng": "English", ...}
|
|
overviews = item.get("overviews") or {}
|
|
if isinstance(overviews, dict):
|
|
overview = (overviews.get(lang)
|
|
or overviews.get("eng")
|
|
or overview)
|
|
|
|
return name, overview
|
|
|
|
async def search_series(self, query: str,
|
|
language: Optional[str] = None) -> list[dict]:
|
|
"""Sucht Serien auf TVDB.
|
|
|
|
Args:
|
|
query: Suchbegriff
|
|
language: Sprache fuer Ergebnisse (z.B. 'deu', 'eng').
|
|
None = konfigurierte Sprache verwenden.
|
|
"""
|
|
client = self._get_client()
|
|
if not client:
|
|
return []
|
|
|
|
# Sprache fuer Lokalisierung
|
|
display_lang = language or self._language
|
|
|
|
try:
|
|
results = client.search(query, type="series")
|
|
if not results:
|
|
return []
|
|
|
|
series_list = []
|
|
for item in results[:20]: # 20 statt 10 Ergebnisse
|
|
# Lokalisierung mit gewaehlter Sprache
|
|
name = item.get("name", "")
|
|
overview = item.get("overview", "")
|
|
|
|
trans = item.get("translations") or {}
|
|
if isinstance(trans, dict):
|
|
# Gewaehlte Sprache oder Original
|
|
name = trans.get(display_lang) or name
|
|
|
|
overviews = item.get("overviews") or {}
|
|
if isinstance(overviews, dict):
|
|
overview = (overviews.get(display_lang)
|
|
or overviews.get("eng")
|
|
or overview)
|
|
|
|
# Original-Name fuer Anzeige wenn anders
|
|
original_name = item.get("name", "")
|
|
|
|
series_list.append({
|
|
"tvdb_id": item.get("tvdb_id") or item.get("objectID"),
|
|
"name": name,
|
|
"original_name": original_name if original_name != name else "",
|
|
"overview": overview,
|
|
"first_air_date": item.get("first_air_time")
|
|
or item.get("firstAirDate", ""),
|
|
"year": item.get("year", ""),
|
|
"status": item.get("status", ""),
|
|
"poster": item.get("thumbnail")
|
|
or item.get("image_url", ""),
|
|
})
|
|
return series_list
|
|
except Exception as e:
|
|
logging.error(f"TVDB Suche fehlgeschlagen: {e}")
|
|
return []
|
|
|
|
async def search_movies(self, query: str) -> list[dict]:
|
|
"""Sucht Filme auf TVDB"""
|
|
client = self._get_client()
|
|
if not client:
|
|
return []
|
|
|
|
try:
|
|
results = client.search(query, type="movie")
|
|
if not results:
|
|
return []
|
|
|
|
movie_list = []
|
|
for item in results[:10]:
|
|
name, overview = self._localize_search_result(item)
|
|
movie_list.append({
|
|
"tvdb_id": item.get("tvdb_id") or item.get("objectID"),
|
|
"name": name,
|
|
"overview": overview,
|
|
"year": item.get("year", ""),
|
|
"poster": item.get("thumbnail")
|
|
or item.get("image_url", ""),
|
|
})
|
|
return movie_list
|
|
except Exception as e:
|
|
logging.error(f"TVDB Film-Suche fehlgeschlagen: {e}")
|
|
return []
|
|
|
|
# === Serien-Info ===
|
|
|
|
async def get_series_info(self, tvdb_id: int) -> Optional[dict]:
|
|
"""Holt Serien-Details von TVDB (Dict-basiert)"""
|
|
client = self._get_client()
|
|
if not client:
|
|
return None
|
|
|
|
try:
|
|
series = client.get_series_extended(tvdb_id)
|
|
if not series:
|
|
return None
|
|
|
|
# API gibt Dict zurueck
|
|
poster_url = series.get("image", "")
|
|
name = series.get("name", "")
|
|
overview = series.get("overview", "")
|
|
|
|
# Lokalisierte Uebersetzung holen (Fallback Englisch)
|
|
pref_lang = self._language
|
|
for lang in (pref_lang, "eng"):
|
|
try:
|
|
trans = client.get_series_translation(tvdb_id, lang)
|
|
if trans:
|
|
if not overview and trans.get("overview"):
|
|
overview = trans["overview"]
|
|
if lang == pref_lang:
|
|
if trans.get("overview"):
|
|
overview = trans["overview"]
|
|
if trans.get("name"):
|
|
name = trans["name"]
|
|
if overview:
|
|
break
|
|
except Exception:
|
|
pass
|
|
|
|
artworks = series.get("artworks") or []
|
|
for art in artworks:
|
|
art_type = art.get("type", {})
|
|
type_id = art_type.get("id", 0) if isinstance(art_type, dict) else art_type
|
|
if type_id == 2:
|
|
poster_url = art.get("image", poster_url)
|
|
break
|
|
|
|
# Staffeln zaehlen
|
|
seasons = []
|
|
for s in (series.get("seasons") or []):
|
|
s_type = s.get("type", {})
|
|
type_id = s_type.get("id", 0) if isinstance(s_type, dict) else 0
|
|
# Typ 1 = official
|
|
if type_id == 1 or not s_type:
|
|
s_num = s.get("number", 0)
|
|
if s_num and s_num > 0:
|
|
seasons.append(s_num)
|
|
|
|
# Genres
|
|
genres = []
|
|
for g in (series.get("genres") or []):
|
|
gname = g.get("name", "")
|
|
if gname:
|
|
genres.append(gname)
|
|
|
|
# Status
|
|
status_obj = series.get("status", {})
|
|
status_name = ""
|
|
if isinstance(status_obj, dict):
|
|
status_name = status_obj.get("name", "")
|
|
elif isinstance(status_obj, str):
|
|
status_name = status_obj
|
|
|
|
return {
|
|
"tvdb_id": tvdb_id,
|
|
"name": name,
|
|
"overview": overview,
|
|
"first_aired": series.get("firstAired", ""),
|
|
"status": status_name,
|
|
"poster_url": poster_url,
|
|
"total_seasons": len(seasons),
|
|
"genres": ", ".join(genres),
|
|
}
|
|
except Exception as e:
|
|
logging.error(f"TVDB Serien-Info fehlgeschlagen (ID {tvdb_id}): {e}")
|
|
return None
|
|
|
|
# === Film-Info ===
|
|
|
|
async def get_movie_info(self, tvdb_id: int) -> Optional[dict]:
|
|
"""Holt Film-Details von TVDB"""
|
|
client = self._get_client()
|
|
if not client:
|
|
return None
|
|
|
|
try:
|
|
movie = client.get_movie_extended(tvdb_id)
|
|
if not movie:
|
|
return None
|
|
|
|
poster_url = movie.get("image", "")
|
|
name = movie.get("name", "")
|
|
overview = movie.get("overview", "")
|
|
|
|
# Lokalisierte Uebersetzung holen (Fallback Englisch)
|
|
pref_lang = self._language
|
|
for lang in (pref_lang, "eng"):
|
|
try:
|
|
trans = client.get_movie_translation(tvdb_id, lang)
|
|
if trans:
|
|
if not overview and trans.get("overview"):
|
|
overview = trans["overview"]
|
|
if lang == pref_lang and trans.get("name"):
|
|
name = trans["name"]
|
|
if overview:
|
|
break
|
|
except Exception:
|
|
pass
|
|
|
|
# Genres
|
|
genres = []
|
|
for g in (movie.get("genres") or []):
|
|
gname = g.get("name", "")
|
|
if gname:
|
|
genres.append(gname)
|
|
|
|
# Status
|
|
status_obj = movie.get("status", {})
|
|
status_name = ""
|
|
if isinstance(status_obj, dict):
|
|
status_name = status_obj.get("name", "")
|
|
elif isinstance(status_obj, str):
|
|
status_name = status_obj
|
|
|
|
# Jahr
|
|
year = movie.get("year")
|
|
if not year:
|
|
first_release = movie.get("first_release", {})
|
|
if isinstance(first_release, dict):
|
|
date_str = first_release.get("date", "")
|
|
if date_str and len(date_str) >= 4:
|
|
try:
|
|
year = int(date_str[:4])
|
|
except ValueError:
|
|
pass
|
|
|
|
return {
|
|
"tvdb_id": tvdb_id,
|
|
"name": name,
|
|
"overview": overview,
|
|
"year": year,
|
|
"poster_url": poster_url,
|
|
"genres": ", ".join(genres),
|
|
"runtime": movie.get("runtime"),
|
|
"status": status_name,
|
|
}
|
|
except Exception as e:
|
|
logging.error(
|
|
f"TVDB Film-Info fehlgeschlagen (ID {tvdb_id}): {e}"
|
|
)
|
|
return None
|
|
|
|
async def match_and_update_movie(self, movie_id: int,
|
|
tvdb_id: int,
|
|
library_service: 'LibraryService'
|
|
) -> dict:
|
|
"""TVDB-ID einem Film zuordnen und Infos aktualisieren"""
|
|
info = await self.get_movie_info(tvdb_id)
|
|
if not info:
|
|
return {"error": "TVDB Film-Info nicht gefunden"}
|
|
|
|
pool = self._db_pool
|
|
if not pool:
|
|
return {"error": "Keine DB-Verbindung"}
|
|
|
|
try:
|
|
async with pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute("""
|
|
UPDATE library_movies SET
|
|
tvdb_id = %s,
|
|
title = %s,
|
|
overview = %s,
|
|
year = %s,
|
|
poster_url = %s,
|
|
genres = %s,
|
|
runtime = %s,
|
|
status = %s,
|
|
last_updated = NOW()
|
|
WHERE id = %s
|
|
""", (
|
|
tvdb_id,
|
|
info["name"],
|
|
info.get("overview", ""),
|
|
info.get("year"),
|
|
info.get("poster_url", ""),
|
|
info.get("genres", ""),
|
|
info.get("runtime"),
|
|
info.get("status", ""),
|
|
movie_id,
|
|
))
|
|
|
|
return {
|
|
"success": True,
|
|
"name": info["name"],
|
|
"year": info.get("year"),
|
|
}
|
|
except Exception as e:
|
|
logging.error(f"TVDB Film-Match fehlgeschlagen: {e}")
|
|
return {"error": str(e)}
|
|
|
|
# === Cast / Characters ===
|
|
|
|
async def get_series_characters(self, tvdb_id: int) -> list[dict]:
|
|
"""Holt Cast/Darsteller von TVDB.
|
|
Prueft zuerst DB-Cache, dann TVDB-API."""
|
|
# Cache pruefen
|
|
cached = await self._get_cached_cast(tvdb_id)
|
|
if cached:
|
|
return cached
|
|
|
|
client = self._get_client()
|
|
if not client:
|
|
return []
|
|
|
|
try:
|
|
series = client.get_series_extended(tvdb_id)
|
|
if not series:
|
|
return []
|
|
|
|
characters = []
|
|
for c in (series.get("characters") or []):
|
|
# type=3 ist Actor
|
|
if c.get("type") != 3:
|
|
continue
|
|
characters.append({
|
|
"person_name": c.get("personName", ""),
|
|
"character_name": c.get("name", ""),
|
|
"sort_order": c.get("sort", 0),
|
|
"image_url": c.get("image", ""),
|
|
"person_image_url": c.get("personImgURL", ""),
|
|
})
|
|
|
|
# Sortieren
|
|
characters.sort(key=lambda x: x.get("sort_order", 999))
|
|
|
|
# In DB cachen
|
|
await self._cache_cast(tvdb_id, characters)
|
|
|
|
return characters
|
|
except Exception as e:
|
|
logging.error(f"TVDB Cast laden fehlgeschlagen (ID {tvdb_id}): {e}")
|
|
return []
|
|
|
|
async def _get_cached_cast(self, tvdb_id: int) -> Optional[list[dict]]:
|
|
"""Cast aus DB-Cache laden"""
|
|
if not self._db_pool:
|
|
return None
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor(aiomysql.DictCursor) as cur:
|
|
await cur.execute(
|
|
"SELECT * FROM tvdb_cast_cache "
|
|
"WHERE series_tvdb_id = %s ORDER BY sort_order",
|
|
(tvdb_id,)
|
|
)
|
|
rows = await cur.fetchall()
|
|
if rows:
|
|
return [self._serialize_row(r) for r in rows]
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
async def _cache_cast(self, tvdb_id: int,
|
|
characters: list[dict]) -> None:
|
|
"""Darsteller in DB cachen"""
|
|
if not self._db_pool:
|
|
return
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute(
|
|
"DELETE FROM tvdb_cast_cache "
|
|
"WHERE series_tvdb_id = %s", (tvdb_id,)
|
|
)
|
|
for c in characters:
|
|
await cur.execute(
|
|
"INSERT INTO tvdb_cast_cache "
|
|
"(series_tvdb_id, person_name, character_name, "
|
|
"sort_order, image_url, person_image_url) "
|
|
"VALUES (%s, %s, %s, %s, %s, %s)",
|
|
(tvdb_id, c["person_name"],
|
|
c["character_name"], c["sort_order"],
|
|
c["image_url"], c["person_image_url"])
|
|
)
|
|
except Exception as e:
|
|
logging.error(f"TVDB Cast cachen fehlgeschlagen: {e}")
|
|
|
|
# === Artworks ===
|
|
|
|
async def get_series_artworks(self, tvdb_id: int) -> list[dict]:
|
|
"""Holt Artworks einer Serie.
|
|
Prueft zuerst DB-Cache, dann TVDB-API."""
|
|
cached = await self._get_cached_artworks(tvdb_id)
|
|
if cached:
|
|
return cached
|
|
|
|
client = self._get_client()
|
|
if not client:
|
|
return []
|
|
|
|
try:
|
|
series = client.get_series_extended(tvdb_id)
|
|
if not series:
|
|
return []
|
|
|
|
artworks = []
|
|
for a in (series.get("artworks") or []):
|
|
art_type_obj = a.get("type", {})
|
|
type_id = art_type_obj.get("id", 0) if isinstance(
|
|
art_type_obj, dict
|
|
) else art_type_obj
|
|
type_name = ARTWORK_TYPE_MAP.get(type_id)
|
|
if not type_name:
|
|
continue
|
|
|
|
artworks.append({
|
|
"artwork_type": type_name,
|
|
"image_url": a.get("image", ""),
|
|
"thumbnail_url": a.get("thumbnail", ""),
|
|
"width": a.get("width", 0),
|
|
"height": a.get("height", 0),
|
|
})
|
|
|
|
# Cachen
|
|
await self._cache_artworks(tvdb_id, artworks)
|
|
|
|
return artworks
|
|
except Exception as e:
|
|
logging.error(f"TVDB Artworks laden fehlgeschlagen (ID {tvdb_id}): {e}")
|
|
return []
|
|
|
|
async def _get_cached_artworks(self, tvdb_id: int) -> Optional[list[dict]]:
|
|
"""Artworks aus DB-Cache laden"""
|
|
if not self._db_pool:
|
|
return None
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor(aiomysql.DictCursor) as cur:
|
|
await cur.execute(
|
|
"SELECT * FROM tvdb_artwork_cache "
|
|
"WHERE series_tvdb_id = %s "
|
|
"ORDER BY artwork_type, is_primary DESC",
|
|
(tvdb_id,)
|
|
)
|
|
rows = await cur.fetchall()
|
|
if rows:
|
|
return [self._serialize_row(r) for r in rows]
|
|
except Exception:
|
|
pass
|
|
return None
|
|
|
|
async def _cache_artworks(self, tvdb_id: int,
|
|
artworks: list[dict]) -> None:
|
|
"""Artworks in DB cachen"""
|
|
if not self._db_pool:
|
|
return
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute(
|
|
"DELETE FROM tvdb_artwork_cache "
|
|
"WHERE series_tvdb_id = %s", (tvdb_id,)
|
|
)
|
|
seen_primary = set()
|
|
for a in artworks:
|
|
art_type = a["artwork_type"]
|
|
is_primary = 1 if art_type not in seen_primary else 0
|
|
seen_primary.add(art_type)
|
|
await cur.execute(
|
|
"INSERT INTO tvdb_artwork_cache "
|
|
"(series_tvdb_id, artwork_type, image_url, "
|
|
"thumbnail_url, width, height, is_primary) "
|
|
"VALUES (%s, %s, %s, %s, %s, %s, %s)",
|
|
(tvdb_id, art_type, a["image_url"],
|
|
a["thumbnail_url"], a["width"],
|
|
a["height"], is_primary)
|
|
)
|
|
except Exception as e:
|
|
logging.error(f"TVDB Artworks cachen fehlgeschlagen: {e}")
|
|
|
|
# === Metadaten herunterladen ===
|
|
|
|
async def download_metadata(self, series_id: int, tvdb_id: int,
|
|
series_folder: str) -> dict:
|
|
"""Laedt Poster, Fanart, Cast-Bilder in .metadata/ Ordner"""
|
|
if not series_folder or not os.path.isdir(series_folder):
|
|
return {"error": "Serien-Ordner nicht gefunden"}
|
|
|
|
meta_dir = os.path.join(series_folder, ".metadata")
|
|
os.makedirs(meta_dir, exist_ok=True)
|
|
cast_dir = os.path.join(meta_dir, "cast")
|
|
os.makedirs(cast_dir, exist_ok=True)
|
|
|
|
downloaded = 0
|
|
errors = 0
|
|
|
|
# Artworks holen (ggf. von API)
|
|
artworks = await self.get_series_artworks(tvdb_id)
|
|
# Cast holen (ggf. von API)
|
|
cast = await self.get_series_characters(tvdb_id)
|
|
|
|
async with aiohttp.ClientSession() as session:
|
|
# Primaere Bilder herunterladen (Poster, Fanart, Banner)
|
|
seen_types = set()
|
|
for art in artworks:
|
|
art_type = art["artwork_type"]
|
|
if art_type in seen_types:
|
|
continue
|
|
if art_type not in ("poster", "fanart", "banner"):
|
|
continue
|
|
seen_types.add(art_type)
|
|
|
|
url = art["image_url"]
|
|
if not url:
|
|
continue
|
|
ext = os.path.splitext(url)[1] or ".jpg"
|
|
target = os.path.join(meta_dir, f"{art_type}{ext}")
|
|
|
|
ok = await self._download_file(session, url, target)
|
|
if ok:
|
|
downloaded += 1
|
|
else:
|
|
errors += 1
|
|
|
|
# Cast-Bilder herunterladen
|
|
for c in cast:
|
|
url = c.get("person_image_url") or c.get("image_url", "")
|
|
name = c.get("person_name", "")
|
|
if not url or not name:
|
|
continue
|
|
# Sicherer Dateiname
|
|
safe_name = "".join(
|
|
ch if ch.isalnum() or ch in " _-" else "_"
|
|
for ch in name
|
|
).strip()
|
|
ext = os.path.splitext(url)[1] or ".jpg"
|
|
target = os.path.join(cast_dir, f"{safe_name}{ext}")
|
|
|
|
ok = await self._download_file(session, url, target)
|
|
if ok:
|
|
downloaded += 1
|
|
else:
|
|
errors += 1
|
|
|
|
# metadata_path in DB setzen
|
|
if self._db_pool:
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute(
|
|
"UPDATE library_series SET metadata_path = %s "
|
|
"WHERE id = %s",
|
|
(meta_dir, series_id)
|
|
)
|
|
except Exception:
|
|
pass
|
|
|
|
logging.info(
|
|
f"TVDB Metadaten heruntergeladen fuer Serie {series_id}: "
|
|
f"{downloaded} Dateien, {errors} Fehler"
|
|
)
|
|
return {
|
|
"success": True,
|
|
"downloaded": downloaded,
|
|
"errors": errors,
|
|
"metadata_path": meta_dir,
|
|
}
|
|
|
|
@staticmethod
|
|
async def _download_file(session: aiohttp.ClientSession,
|
|
url: str, target: str) -> bool:
|
|
"""Einzelne Datei herunterladen"""
|
|
try:
|
|
async with session.get(url, timeout=aiohttp.ClientTimeout(total=30)) as resp:
|
|
if resp.status != 200:
|
|
return False
|
|
data = await resp.read()
|
|
with open(target, "wb") as f:
|
|
f.write(data)
|
|
return True
|
|
except Exception as e:
|
|
logging.warning(f"Download fehlgeschlagen: {url}: {e}")
|
|
return False
|
|
|
|
# === Episoden ===
|
|
|
|
async def fetch_episodes(self, tvdb_id: int) -> list[dict]:
|
|
"""Holt alle Episoden einer Serie von TVDB und cached sie in DB.
|
|
Nutzt konfigurierte Sprache fuer Episodennamen."""
|
|
client = self._get_client()
|
|
if not client:
|
|
return []
|
|
|
|
pref_lang = self._language
|
|
|
|
try:
|
|
episodes = []
|
|
page = 0
|
|
while True:
|
|
# Mit Sprach-Parameter abrufen fuer lokalisierte Namen
|
|
result = client.get_series_episodes(
|
|
tvdb_id, season_type="official", page=page,
|
|
lang=pref_lang,
|
|
)
|
|
if not result:
|
|
break
|
|
# API gibt Dict zurueck, kein Objekt
|
|
if isinstance(result, dict):
|
|
eps = result.get("episodes", [])
|
|
elif hasattr(result, "episodes"):
|
|
eps = result.episodes
|
|
else:
|
|
break
|
|
if not eps:
|
|
break
|
|
for ep in eps:
|
|
if isinstance(ep, dict):
|
|
s_num = ep.get("seasonNumber", 0)
|
|
e_num = ep.get("number", 0)
|
|
ep_name = ep.get("name", "")
|
|
ep_aired = ep.get("aired")
|
|
ep_runtime = ep.get("runtime")
|
|
else:
|
|
s_num = getattr(ep, "seasonNumber", 0)
|
|
e_num = getattr(ep, "number", 0)
|
|
ep_name = getattr(ep, "name", "")
|
|
ep_aired = getattr(ep, "aired", None)
|
|
ep_runtime = getattr(ep, "runtime", None)
|
|
if s_num and s_num > 0 and e_num and e_num > 0:
|
|
episodes.append({
|
|
"season_number": s_num,
|
|
"episode_number": e_num,
|
|
"episode_name": ep_name or "",
|
|
"aired": ep_aired,
|
|
"runtime": ep_runtime,
|
|
})
|
|
page += 1
|
|
if page > 50:
|
|
break
|
|
|
|
if episodes and self._db_pool:
|
|
await self._cache_episodes(tvdb_id, episodes)
|
|
|
|
logging.info(f"TVDB: {len(episodes)} Episoden fuer "
|
|
f"Serie {tvdb_id} geladen ({pref_lang})")
|
|
return episodes
|
|
except Exception as e:
|
|
logging.error(f"TVDB Episoden laden fehlgeschlagen "
|
|
f"(ID {tvdb_id}): {e}")
|
|
return []
|
|
|
|
async def _cache_episodes(self, tvdb_id: int,
|
|
episodes: list[dict]) -> None:
|
|
"""Episoden in DB cachen"""
|
|
if not self._db_pool:
|
|
return
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute(
|
|
"DELETE FROM tvdb_episode_cache "
|
|
"WHERE series_tvdb_id = %s",
|
|
(tvdb_id,)
|
|
)
|
|
for ep in episodes:
|
|
await cur.execute(
|
|
"INSERT INTO tvdb_episode_cache "
|
|
"(series_tvdb_id, season_number, episode_number, "
|
|
"episode_name, aired, runtime) "
|
|
"VALUES (%s, %s, %s, %s, %s, %s)",
|
|
(
|
|
tvdb_id, ep["season_number"],
|
|
ep["episode_number"], ep["episode_name"],
|
|
ep["aired"], ep["runtime"],
|
|
)
|
|
)
|
|
except Exception as e:
|
|
logging.error(f"TVDB Episode cachen fehlgeschlagen: {e}")
|
|
|
|
# === Match & Update ===
|
|
|
|
async def match_and_update_series(self, series_id: int,
|
|
tvdb_id: int,
|
|
library_service: 'LibraryService'
|
|
) -> dict:
|
|
"""TVDB-ID zuordnen, Infos holen, Episoden + Cast + Artworks cachen"""
|
|
info = await self.get_series_info(tvdb_id)
|
|
if not info:
|
|
return {"error": "TVDB-Serien-Info nicht gefunden"}
|
|
|
|
episodes = await self.fetch_episodes(tvdb_id)
|
|
|
|
# Cast und Artworks cachen (im Hintergrund)
|
|
await self.get_series_characters(tvdb_id)
|
|
await self.get_series_artworks(tvdb_id)
|
|
|
|
pool = self._db_pool
|
|
if not pool:
|
|
return {"error": "Keine DB-Verbindung"}
|
|
|
|
try:
|
|
async with pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute("""
|
|
UPDATE library_series SET
|
|
tvdb_id = %s,
|
|
title = %s,
|
|
overview = %s,
|
|
first_aired = %s,
|
|
poster_url = %s,
|
|
status = %s,
|
|
total_seasons = %s,
|
|
total_episodes = %s,
|
|
genres = %s,
|
|
last_updated = NOW()
|
|
WHERE id = %s
|
|
""", (
|
|
tvdb_id,
|
|
info["name"],
|
|
info.get("overview", ""),
|
|
info.get("first_aired") or None,
|
|
info.get("poster_url", ""),
|
|
info.get("status", ""),
|
|
info.get("total_seasons", 0),
|
|
len(episodes),
|
|
info.get("genres", ""),
|
|
series_id,
|
|
))
|
|
|
|
await self._update_episode_titles(series_id, tvdb_id)
|
|
await library_service._update_series_counts(series_id)
|
|
|
|
return {
|
|
"success": True,
|
|
"name": info["name"],
|
|
"total_episodes": len(episodes),
|
|
}
|
|
except Exception as e:
|
|
logging.error(f"TVDB Match fehlgeschlagen: {e}")
|
|
return {"error": str(e)}
|
|
|
|
async def _update_episode_titles(self, series_id: int,
|
|
tvdb_id: int) -> None:
|
|
"""Episoden-Titel aus TVDB-Cache in lokale Videos uebertragen"""
|
|
if not self._db_pool:
|
|
return
|
|
try:
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor() as cur:
|
|
await cur.execute("""
|
|
UPDATE library_videos v
|
|
JOIN tvdb_episode_cache tc
|
|
ON tc.series_tvdb_id = %s
|
|
AND tc.season_number = v.season_number
|
|
AND tc.episode_number = v.episode_number
|
|
SET v.episode_title = tc.episode_name
|
|
WHERE v.series_id = %s
|
|
""", (tvdb_id, series_id))
|
|
except Exception as e:
|
|
logging.error(f"Episoden-Titel aktualisieren fehlgeschlagen: {e}")
|
|
|
|
# === Auto-Match ===
|
|
|
|
@staticmethod
|
|
def _clean_search_title(title: str) -> tuple[str, str]:
|
|
"""Bereinigt Titel fuer bessere TVDB-Suche.
|
|
Entfernt fuehrende Sortier-Nummern, Aufloesung-Suffixe, Klammern."""
|
|
import re
|
|
t = title.strip()
|
|
# Fuehrende Sortier-Nummern entfernen ("1 X-Men" -> "X-Men")
|
|
t = re.sub(r'^\d{1,2}\s+', '', t)
|
|
# Aufloesung/Qualitaets-Suffixe entfernen
|
|
t = re.sub(
|
|
r'\s*(720p|1080p|2160p|4k|bluray|bdrip|webrip|web-dl|hdtv|'
|
|
r'x264|x265|hevc|aac|dts|remux)\s*',
|
|
' ', t, flags=re.IGNORECASE
|
|
).strip()
|
|
# Klammern mit Inhalt entfernen "(2020)" etc.
|
|
t_no_parens = re.sub(r'\s*\([^)]*\)\s*', ' ', t).strip()
|
|
# Trailing-Nummern entfernen ("X-Men 1" -> "X-Men")
|
|
t_no_num = re.sub(r'\s+\d{1,2}$', '', t)
|
|
# Variante 1: bereinigt, Variante 2: ohne Klammern und Trailing-Nummern
|
|
clean1 = t.strip()
|
|
clean2 = t_no_parens.strip() if t_no_parens != clean1 else t_no_num.strip()
|
|
return clean1, clean2
|
|
|
|
async def collect_suggestions(
|
|
self,
|
|
media_type: str,
|
|
progress_callback=None,
|
|
) -> list[dict]:
|
|
"""Sammelt TVDB-Vorschlaege fuer alle Serien oder Filme ohne TVDB.
|
|
media_type: 'series' oder 'movies'
|
|
Gibt Liste von Vorschlaegen zurueck: [{
|
|
id, local_name, year, type,
|
|
suggestions: [{tvdb_id, name, year, poster, overview}]
|
|
}]"""
|
|
if not self._db_pool:
|
|
return []
|
|
|
|
# Items ohne TVDB laden
|
|
async with self._db_pool.acquire() as conn:
|
|
async with conn.cursor(aiomysql.DictCursor) as cur:
|
|
if media_type == "series":
|
|
await cur.execute(
|
|
"SELECT id, folder_name, title "
|
|
"FROM library_series WHERE tvdb_id IS NULL "
|
|
"ORDER BY title"
|
|
)
|
|
else:
|
|
await cur.execute(
|
|
"SELECT id, folder_name, title, year "
|
|
"FROM library_movies WHERE tvdb_id IS NULL "
|
|
"ORDER BY title"
|
|
)
|
|
items = await cur.fetchall()
|
|
|
|
total = len(items)
|
|
proposals = []
|
|
|
|
for i, item in enumerate(items):
|
|
name = item.get("title") or item["folder_name"]
|
|
t_full, t_clean = self._clean_search_title(name)
|
|
|
|
try:
|
|
search_fn = (self.search_series if media_type == "series"
|
|
else self.search_movies)
|
|
results = await search_fn(t_full)
|
|
if not results and t_clean != t_full:
|
|
results = await search_fn(t_clean)
|
|
except Exception as e:
|
|
logging.warning(f"TVDB-Suche fehlgeschlagen: {name}: {e}")
|
|
results = []
|
|
|
|
# Top 3 Vorschlaege sammeln
|
|
suggestions = []
|
|
for r in (results or [])[:3]:
|
|
suggestions.append({
|
|
"tvdb_id": r.get("tvdb_id"),
|
|
"name": r.get("name", ""),
|
|
"year": r.get("year", ""),
|
|
"poster": r.get("poster", ""),
|
|
"overview": (r.get("overview") or "")[:150],
|
|
})
|
|
|
|
proposals.append({
|
|
"id": item["id"],
|
|
"local_name": name,
|
|
"year": item.get("year"),
|
|
"type": media_type,
|
|
"suggestions": suggestions,
|
|
})
|
|
|
|
if progress_callback:
|
|
await progress_callback(
|
|
i + 1, total, name, len(proposals)
|
|
)
|
|
|
|
return proposals
|