Add Jellyfin library discovery and Trickplay indexing

This commit is contained in:
Sleeps
2026-10-06 15:38:25 +01:00
parent b40ec58aed
commit 6da2de99bf
+348
View File
@@ -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")