mirror of
https://github.com/MrSleeps/jellyfin-scene-search.git
synced 2026-11-19 00:03:36 +00:00
409 lines
15 KiB
Python
409 lines
15 KiB
Python
from __future__ import annotations
|
|
|
|
import threading
|
|
from copy import deepcopy
|
|
from datetime import datetime, timezone
|
|
from typing import Any
|
|
|
|
from .database import connect, init_db
|
|
from .index_report import load_index_report, save_index_report
|
|
from .jellyfin_index import (
|
|
build_jellyfin_client,
|
|
index_libraries,
|
|
reconcile_selected_libraries,
|
|
resolve_library_ids,
|
|
)
|
|
from .search_service import SearchService
|
|
from .sync import rebuild_meili
|
|
|
|
|
|
class IndexJobManager:
|
|
"""Runs one plugin-triggered Jellyfin indexing job at a time."""
|
|
|
|
def __init__(self, search_service: SearchService) -> None:
|
|
self.search_service = search_service
|
|
self._state_lock = threading.Lock()
|
|
self._thread: threading.Thread | None = None
|
|
self._state: dict[str, Any] = {
|
|
"running": False,
|
|
"stage": "idle",
|
|
"started_at": None,
|
|
"finished_at": None,
|
|
"error": None,
|
|
}
|
|
|
|
@property
|
|
def running(self) -> bool:
|
|
with self._state_lock:
|
|
return bool(self._state.get("running"))
|
|
|
|
def status(self) -> dict[str, Any]:
|
|
with self._state_lock:
|
|
return deepcopy(self._state)
|
|
|
|
def report(
|
|
self,
|
|
*,
|
|
category: str | None = None,
|
|
offset: int = 0,
|
|
limit: int = 200,
|
|
) -> dict[str, Any]:
|
|
report = load_index_report()
|
|
items = list(report.get("items") or [])
|
|
if category:
|
|
items = [
|
|
item
|
|
for item in items
|
|
if str(item.get("status") or "") == category
|
|
]
|
|
|
|
total = len(items)
|
|
page = items[offset:offset + limit]
|
|
return {
|
|
"available": bool(report.get("available", False)),
|
|
"kind": report.get("kind"),
|
|
"status": report.get("status"),
|
|
"started_at": report.get("started_at"),
|
|
"finished_at": report.get("finished_at"),
|
|
"error": report.get("error"),
|
|
"summary": report.get("summary") or {},
|
|
"category": category,
|
|
"offset": offset,
|
|
"limit": limit,
|
|
"total": total,
|
|
"items": page,
|
|
}
|
|
|
|
def libraries(self) -> list[dict[str, Any]]:
|
|
client = build_jellyfin_client()
|
|
libraries = client.media_folders()
|
|
init_db(self.search_service.db_path)
|
|
|
|
counts: dict[str, tuple[int, int]] = {}
|
|
with connect(self.search_service.db_path) as con:
|
|
rows = con.execute(
|
|
"""
|
|
SELECT m.jellyfin_library_id,
|
|
COUNT(DISTINCT m.id) AS indexed_items,
|
|
COUNT(f.id) AS indexed_frames
|
|
FROM media m
|
|
LEFT JOIN frames f ON f.media_id = m.id
|
|
WHERE m.source_kind = 'jellyfin'
|
|
AND m.jellyfin_library_id IS NOT NULL
|
|
GROUP BY m.jellyfin_library_id
|
|
"""
|
|
).fetchall()
|
|
for row in rows:
|
|
counts[str(row["jellyfin_library_id"])] = (
|
|
int(row["indexed_items"]),
|
|
int(row["indexed_frames"]),
|
|
)
|
|
|
|
result = []
|
|
for library in sorted(
|
|
libraries,
|
|
key=lambda item: str(item.get("Name") or "").casefold(),
|
|
):
|
|
library_id = str(library.get("Id") or "")
|
|
indexed_items, indexed_frames = counts.get(library_id, (0, 0))
|
|
result.append(
|
|
{
|
|
"id": library_id,
|
|
"name": str(library.get("Name") or library_id),
|
|
"indexed_items": indexed_items,
|
|
"indexed_frames": indexed_frames,
|
|
}
|
|
)
|
|
return result
|
|
|
|
def apply_library_selection(self, library_ids: list[str]) -> dict[str, object]:
|
|
with self._state_lock:
|
|
if self._state.get("running"):
|
|
raise RuntimeError("A Jellyfin indexing job is already running.")
|
|
|
|
selected_ids = {
|
|
str(value).strip()
|
|
for value in library_ids
|
|
if str(value).strip()
|
|
}
|
|
started_at = datetime.now(timezone.utc).isoformat()
|
|
result = reconcile_selected_libraries(selected_ids)
|
|
removed_items = list(result.pop("removed_items", []) or [])
|
|
removed_ids = [
|
|
str(value)
|
|
for value in (result.get("removed_library_ids") or [])
|
|
]
|
|
if removed_ids:
|
|
self.search_service.meili.delete_jellyfin_libraries(removed_ids)
|
|
print(
|
|
"Removed deselected Jellyfin libraries: "
|
|
+ ", ".join(removed_ids)
|
|
+ f" ({int(result.get('removed_media') or 0)} media item(s))"
|
|
)
|
|
|
|
finished_at = datetime.now(timezone.utc).isoformat()
|
|
save_index_report(
|
|
{
|
|
"available": True,
|
|
"kind": "library_selection",
|
|
"status": "complete",
|
|
"started_at": started_at,
|
|
"finished_at": finished_at,
|
|
"error": None,
|
|
"summary": {
|
|
"indexed": 0,
|
|
"skipped": 0,
|
|
"failed": 0,
|
|
"pruned": int(result.get("removed_media") or 0),
|
|
"removed_libraries": int(result.get("removed_libraries") or 0),
|
|
},
|
|
"items": removed_items,
|
|
}
|
|
)
|
|
return result
|
|
|
|
def start(self, library_ids: list[str], *, force: bool = False) -> dict[str, Any]:
|
|
with self._state_lock:
|
|
if self._state.get("running"):
|
|
raise RuntimeError("A Jellyfin indexing job is already running.")
|
|
|
|
requested_ids = [
|
|
str(value).strip()
|
|
for value in library_ids
|
|
if str(value).strip()
|
|
]
|
|
client = build_jellyfin_client()
|
|
libraries = (
|
|
resolve_library_ids(client, requested_ids)
|
|
if requested_ids
|
|
else []
|
|
)
|
|
selected_ids = {
|
|
str(item.get("Id") or "")
|
|
for item in libraries
|
|
if str(item.get("Id") or "")
|
|
}
|
|
library_item_totals = [
|
|
client.item_count(str(item.get("Id") or ""))
|
|
for item in libraries
|
|
]
|
|
overall_items_total = sum(library_item_totals)
|
|
|
|
with self._state_lock:
|
|
self._state = {
|
|
"running": True,
|
|
"stage": "starting",
|
|
"started_at": datetime.now(timezone.utc).isoformat(),
|
|
"finished_at": None,
|
|
"error": None,
|
|
"library_total": len(libraries),
|
|
"library_ids": sorted(selected_ids),
|
|
"library_item_totals": library_item_totals,
|
|
"overall_items_total": overall_items_total,
|
|
"overall_items_completed": 0,
|
|
"overall_percent": 0.0,
|
|
}
|
|
|
|
self._thread = threading.Thread(
|
|
target=self._run,
|
|
args=(libraries, selected_ids, force),
|
|
name="scene-search-index",
|
|
daemon=True,
|
|
)
|
|
self._thread.start()
|
|
return self.status()
|
|
|
|
def _progress(self, update: dict) -> None:
|
|
with self._state_lock:
|
|
self._state.update(update)
|
|
self._update_overall_progress_locked()
|
|
|
|
def _update_overall_progress_locked(self) -> None:
|
|
stage = str(self._state.get("stage") or "")
|
|
total = int(self._state.get("overall_items_total") or 0)
|
|
totals = [
|
|
int(value)
|
|
for value in (self._state.get("library_item_totals") or [])
|
|
]
|
|
|
|
if stage == "complete":
|
|
self._state["overall_items_completed"] = total
|
|
self._state["overall_percent"] = 100.0
|
|
return
|
|
|
|
if stage in {"indexed", "syncing", "sync", "synced"}:
|
|
self._state["overall_items_completed"] = total
|
|
self._state["overall_percent"] = 99.0 if total else 99.0
|
|
return
|
|
|
|
library_number = int(self._state.get("library_number") or 1)
|
|
library_index = max(0, min(library_number - 1, len(totals)))
|
|
before_library = sum(totals[:library_index])
|
|
|
|
item_number = int(self._state.get("item_number") or 0)
|
|
completed_before_item = max(item_number - 1, 0)
|
|
completed = min(before_library + completed_before_item, total)
|
|
|
|
fractional_item = 0.0
|
|
frames_total = int(self._state.get("frames_total") or 0)
|
|
frames_processed = int(self._state.get("frames_processed") or 0)
|
|
if stage == "embedding" and frames_total > 0:
|
|
fractional_item = min(max(frames_processed / frames_total, 0.0), 1.0)
|
|
|
|
position = min(completed + fractional_item, float(total))
|
|
self._state["overall_items_completed"] = completed
|
|
self._state["overall_percent"] = (
|
|
round((position / total) * 99.0, 1)
|
|
if total > 0
|
|
else 0.0
|
|
)
|
|
|
|
def _run(
|
|
self,
|
|
libraries: list[dict],
|
|
selected_ids: set[str],
|
|
force: bool,
|
|
) -> None:
|
|
report_items: list[dict[str, object]] = []
|
|
started_at = str(self.status().get("started_at") or datetime.now(timezone.utc).isoformat())
|
|
try:
|
|
removed = reconcile_selected_libraries(selected_ids)
|
|
report_items.extend(list(removed.pop("removed_items", []) or []))
|
|
removed_ids = [
|
|
str(value)
|
|
for value in (removed.get("removed_library_ids") or [])
|
|
]
|
|
if removed_ids:
|
|
self.search_service.meili.delete_jellyfin_libraries(removed_ids)
|
|
self._progress(
|
|
{
|
|
"removed_libraries": int(removed["removed_libraries"]),
|
|
"removed_library_media": int(removed["removed_media"]),
|
|
}
|
|
)
|
|
print(
|
|
"Removed deselected Jellyfin libraries: "
|
|
+ ", ".join(removed_ids)
|
|
+ f" ({int(removed.get('removed_media') or 0)} media item(s))"
|
|
)
|
|
|
|
if not libraries:
|
|
finished_at = datetime.now(timezone.utc).isoformat()
|
|
summary = {
|
|
"library_total": 0,
|
|
"indexed": 0,
|
|
"skipped": 0,
|
|
"failed": 0,
|
|
"pruned": int(removed.get("removed_media") or 0),
|
|
"removed_libraries": int(removed.get("removed_libraries") or 0),
|
|
}
|
|
self._progress(
|
|
{
|
|
"running": False,
|
|
"stage": "complete",
|
|
"finished_at": finished_at,
|
|
"documents_processed": 0,
|
|
**summary,
|
|
}
|
|
)
|
|
save_index_report(
|
|
{
|
|
"available": True,
|
|
"kind": "index",
|
|
"status": "complete",
|
|
"started_at": started_at,
|
|
"finished_at": finished_at,
|
|
"error": None,
|
|
"summary": summary,
|
|
"items": report_items,
|
|
}
|
|
)
|
|
return
|
|
|
|
# Search and indexing share one model instance and never use it concurrently.
|
|
with self.search_service.model_lock:
|
|
embedder = self.search_service.get_embedder()
|
|
_, summary = index_libraries(
|
|
build_jellyfin_client(),
|
|
libraries,
|
|
embedder=embedder,
|
|
force=force,
|
|
progress=self._progress,
|
|
report_items=report_items,
|
|
)
|
|
retained_index_changed = (
|
|
int(summary.get("indexed") or 0) > 0
|
|
or int(summary.get("pruned") or 0) > 0
|
|
)
|
|
summary["pruned"] = (
|
|
int(summary.get("pruned") or 0)
|
|
+ int(removed.get("removed_media") or 0)
|
|
)
|
|
summary["removed_libraries"] = int(
|
|
removed.get("removed_libraries") or 0
|
|
)
|
|
|
|
if retained_index_changed:
|
|
self._progress({"stage": "syncing", **summary})
|
|
documents = rebuild_meili(progress=self._progress)
|
|
else:
|
|
documents = 0
|
|
print(
|
|
"Selected libraries are unchanged; "
|
|
"skipping full Meilisearch rebuild."
|
|
)
|
|
|
|
finished_at = datetime.now(timezone.utc).isoformat()
|
|
self._progress(
|
|
{
|
|
"running": False,
|
|
"stage": "complete",
|
|
"finished_at": finished_at,
|
|
"documents_processed": documents,
|
|
"full_meili_rebuild": retained_index_changed,
|
|
**summary,
|
|
}
|
|
)
|
|
save_index_report(
|
|
{
|
|
"available": True,
|
|
"kind": "index",
|
|
"status": "complete",
|
|
"started_at": started_at,
|
|
"finished_at": finished_at,
|
|
"error": None,
|
|
"summary": {
|
|
**summary,
|
|
"documents_processed": documents,
|
|
"full_meili_rebuild": retained_index_changed,
|
|
},
|
|
"items": report_items,
|
|
}
|
|
)
|
|
except Exception as exc:
|
|
finished_at = datetime.now(timezone.utc).isoformat()
|
|
self._progress(
|
|
{
|
|
"running": False,
|
|
"stage": "failed",
|
|
"finished_at": finished_at,
|
|
"error": str(exc),
|
|
}
|
|
)
|
|
save_index_report(
|
|
{
|
|
"available": True,
|
|
"kind": "index",
|
|
"status": "failed",
|
|
"started_at": started_at,
|
|
"finished_at": finished_at,
|
|
"error": str(exc),
|
|
"summary": {
|
|
"indexed": sum(1 for item in report_items if item.get("status") == "indexed"),
|
|
"failed": sum(1 for item in report_items if item.get("status") == "failed"),
|
|
"pruned": sum(1 for item in report_items if item.get("status") == "removed"),
|
|
},
|
|
"items": report_items,
|
|
}
|
|
)
|