diff --git a/scene_search/jellyfin_index.py b/scene_search/jellyfin_index.py new file mode 100644 index 0000000..5cab165 --- /dev/null +++ b/scene_search/jellyfin_index.py @@ -0,0 +1,348 @@ +from __future__ import annotations + +import hashlib +from pathlib import Path + +from PIL import Image + +from .config import settings +from .database import connect, init_db, pack_vector +from .embedder import SiglipEmbedder +from .frames import extract_frames +from .jellyfin import ( + JellyfinClient, + item_tags, + jellyfin_media_id, + primary_media_source, + tags_to_json, +) + + +def build_jellyfin_client() -> JellyfinClient: + return JellyfinClient( + settings.jellyfin_url, + settings.jellyfin_api_key, + settings.jellyfin_timeout_seconds, + ) + + +def resolve_library_name(requested: str | None) -> str: + name = (requested or settings.jellyfin_library).strip() + if not name: + raise RuntimeError( + "No Jellyfin library selected. Pass --library or set JELLYFIN_LIBRARY." + ) + return name + + +def _display_tags(tags: list[str]) -> str: + return ", ".join(tags) if tags else "-" + + +def cmd_jellyfin_test(_: object) -> None: + client = build_jellyfin_client() + info = client.system_info() + libraries = client.media_folders() + print( + f"Connected to Jellyfin {info.get('Version', '?')} " + f"({info.get('ServerName') or info.get('ProductName') or 'server'})" + ) + print(f"Libraries visible to API key: {len(libraries)}") + + +def cmd_jellyfin_libraries(_: object) -> None: + client = build_jellyfin_client() + libraries = client.media_folders() + if not libraries: + print("No Jellyfin libraries returned.") + return + + for item in sorted(libraries, key=lambda row: str(row.get("Name") or "")): + print(f"{item.get('Name') or '(unnamed)'}\t{item.get('Id')}") + + +def cmd_jellyfin_items(args: object) -> None: + client = build_jellyfin_client() + library_name = resolve_library_name(getattr(args, "library", None)) + library = client.find_library(library_name) + summaries = client.items(str(library["Id"]), limit=getattr(args, "limit", None)) + + if not summaries: + print(f"No video items found in {library_name!r}.") + return + + for summary in summaries: + detail = client.item(str(summary["Id"])) + tags = item_tags(detail) + trickplay = client.select_trickplay(detail, settings.jellyfin_trickplay_width) + tp = ( + f"{trickplay.width}px/{trickplay.interval_ms}ms/" + f"{trickplay.thumbnail_count} thumbs" + if trickplay + else "none" + ) + print( + f"{detail.get('Name') or summary.get('Name') or '(unnamed)'}\n" + f" id: {detail.get('Id')}\n" + f" type: {detail.get('Type')}\n" + f" tags: {_display_tags(tags)}\n" + f" trickplay: {tp}\n" + f" path: {detail.get('Path') or '-'}" + ) + + +def _embed_frames( + embedder: SiglipEmbedder, + frame_paths: list[Path], + media_id: str, + interval_ms: int, +) -> tuple[list[tuple], int]: + rows: list[tuple] = [] + dim: int | None = None + + for start in range(0, len(frame_paths), settings.batch_size): + batch_paths = frame_paths[start:start + settings.batch_size] + images: list[Image.Image] = [] + try: + for frame_path in batch_paths: + images.append(Image.open(frame_path).convert("RGB")) + vectors = embedder.embed_images(images) + finally: + for image in images: + image.close() + + dim = int(vectors.shape[1]) + for offset, (frame_path, vector) in enumerate( + zip(batch_paths, vectors, strict=True) + ): + frame_number = start + offset + timestamp_ms = frame_number * interval_ms + frame_id = hashlib.sha256( + f"{media_id}:{timestamp_ms}:{settings.model_id}".encode() + ).hexdigest()[:40] + rows.append( + ( + frame_id, + media_id, + frame_number, + timestamp_ms, + str(frame_path), + pack_vector(vector), + ) + ) + + print( + f" embedded " + f"{min(start + len(batch_paths), len(frame_paths))}/{len(frame_paths)}" + ) + + if dim is None: + raise RuntimeError("No frames were embedded") + return rows, dim + + +def cmd_jellyfin_index(args: object) -> None: + init_db(settings.db_path) + client = build_jellyfin_client() + library_name = resolve_library_name(getattr(args, "library", None)) + library = client.find_library(library_name) + summaries = client.items(str(library["Id"]), limit=getattr(args, "limit", None)) + force = bool(getattr(args, "force", False)) + + print( + f"Jellyfin library {library_name!r}: {len(summaries)} video item(s) selected" + ) + + embedder: SiglipEmbedder | None = None + indexed = 0 + skipped = 0 + failed = 0 + + for number, summary in enumerate(summaries, 1): + try: + detail = client.item(str(summary["Id"])) + item_id = str(detail.get("Id") or summary["Id"]) + title = str(detail.get("Name") or summary.get("Name") or item_id) + tags = item_tags(detail) + normalized_tags = {tag.casefold() for tag in tags} + + if settings.jellyfin_skip_tag and settings.jellyfin_skip_tag in normalized_tags: + print(f"[{number}/{len(summaries)}] SKIP {title}: Jellyfin skip tag") + skipped += 1 + continue + + selection = client.select_trickplay( + detail, + settings.jellyfin_trickplay_width, + ) + source = primary_media_source(detail) + source_path_text = str( + detail.get("Path") + or source.get("Path") + or f"jellyfin://{item_id}" + ) + media_id = jellyfin_media_id(item_id) + etag = str(detail.get("Etag") or "") + content_marker = hashlib.sha256( + f"jellyfin:{item_id}:{etag}".encode() + ).hexdigest() + + expected_interval_ms = ( + selection.interval_ms + if selection + else int(round(settings.jellyfin_fallback_interval_seconds * 1000)) + ) + + with connect(settings.db_path) as con: + existing = con.execute( + "SELECT * FROM media WHERE jellyfin_item_id = ?", + (item_id,), + ).fetchone() + + if ( + existing + and existing["jellyfin_etag"] == etag + and existing["model_id"] == settings.model_id + and int(existing["interval_ms"]) == expected_interval_ms + and not force + ): + frame_count = 0 + with connect(settings.db_path) as con: + frame_count = int( + con.execute( + "SELECT COUNT(*) FROM frames WHERE media_id = ?", + (existing["id"],), + ).fetchone()[0] + ) + print( + f"[{number}/{len(summaries)}] {title}: already indexed " + f"({frame_count} frames)" + ) + skipped += 1 + continue + + out_dir = settings.thumbs_dir / media_id + if selection: + print( + f"[{number}/{len(summaries)}] {title}: Trickplay " + f"{selection.width}px every {selection.interval_ms / 1000:g}s" + ) + frame_paths = client.download_trickplay_frames( + item_id, + selection, + out_dir, + ) + interval_ms = selection.interval_ms + media_source_id = selection.media_source_id + trickplay_width = selection.width + trickplay_tile_width = selection.tile_columns + trickplay_tile_height = selection.tile_rows + else: + local_path = Path(source_path_text) + if not local_path.is_file(): + print( + f"[{number}/{len(summaries)}] SKIP {title}: " + "no Trickplay and media path is not locally accessible" + ) + failed += 1 + continue + + print( + f"[{number}/{len(summaries)}] {title}: no Trickplay; " + f"ffmpeg fallback every " + f"{settings.jellyfin_fallback_interval_seconds:g}s" + ) + frame_paths = extract_frames( + local_path, + out_dir, + settings.jellyfin_fallback_interval_seconds, + ) + interval_ms = int( + round(settings.jellyfin_fallback_interval_seconds * 1000) + ) + media_source_id = str(source.get("Id") or "") or None + trickplay_width = None + trickplay_tile_width = None + trickplay_tile_height = None + + if not frame_paths: + print(f"[{number}/{len(summaries)}] SKIP {title}: no frames") + failed += 1 + continue + + if embedder is None: + print(f"Loading {settings.model_id} on {settings.device}...") + embedder = SiglipEmbedder(settings.model_id, settings.device) + + frame_rows, embedding_dim = _embed_frames( + embedder, + frame_paths, + media_id, + interval_ms, + ) + + size_bytes = int(source.get("Size") or 0) + with connect(settings.db_path) as con: + con.execute("DELETE FROM media WHERE id = ?", (media_id,)) + con.execute( + """ + INSERT INTO media ( + id, source_path, title, content_sha256, size_bytes, mtime_ns, + interval_ms, model_id, embedding_dim, source_kind, + jellyfin_item_id, jellyfin_media_source_id, jellyfin_library_id, + jellyfin_item_type, jellyfin_tags, jellyfin_etag, + trickplay_width, trickplay_tile_width, trickplay_tile_height + ) + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) + """, + ( + media_id, + source_path_text, + title, + content_marker, + size_bytes, + 0, + interval_ms, + settings.model_id, + embedding_dim, + "jellyfin", + item_id, + media_source_id, + str(library["Id"]), + str(detail.get("Type") or ""), + tags_to_json(tags), + etag, + trickplay_width, + trickplay_tile_width, + trickplay_tile_height, + ), + ) + con.executemany( + """ + INSERT INTO frames ( + id, media_id, frame_number, timestamp_ms, + thumb_path, embedding_f16 + ) + VALUES (?, ?, ?, ?, ?, ?) + """, + frame_rows, + ) + + print( + f" stored {len(frame_rows)} frames; tags={_display_tags(tags)}" + ) + indexed += 1 + + except Exception as exc: + failed += 1 + print( + f"[{number}/{len(summaries)}] FAIL " + f"{summary.get('Name') or summary.get('Id')}: {exc}" + ) + + print( + f"Jellyfin indexing complete: {indexed} indexed, " + f"{skipped} skipped, {failed} failed." + ) + if indexed: + print("Next: python -m scene_search.cli caption --sync")