mirror of
https://github.com/MrSleeps/jellyfin-scene-search.git
synced 2026-11-16 23:11:27 +00:00
219 lines
9.7 KiB
Python
219 lines
9.7 KiB
Python
from __future__ import annotations
|
|
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
from unittest.mock import Mock
|
|
|
|
import numpy as np
|
|
|
|
from scene_search.caption_editor import captioned_media, correct_caption
|
|
from scene_search.database import connect, init_db, pack_vector
|
|
|
|
|
|
class CaptionEditorTests(unittest.TestCase):
|
|
def seed(self, db_path: Path) -> None:
|
|
init_db(db_path)
|
|
with connect(db_path) as con:
|
|
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_library_id
|
|
) VALUES (
|
|
'm1', 'jellyfin://movie1', 'Some Movie', 'hash',
|
|
1, 0, 30000, 'model', 2, 'jellyfin',
|
|
'jf-1', 'library-1'
|
|
)"""
|
|
)
|
|
vector = pack_vector(np.asarray([1.0, 0.0], dtype=np.float32))
|
|
for n in range(3):
|
|
con.execute(
|
|
"""INSERT INTO frames (
|
|
id, media_id, frame_number, timestamp_ms,
|
|
thumb_path, embedding_f16, caption
|
|
) VALUES (?, 'm1', ?, ?, '', ?, ?)""",
|
|
(
|
|
f"f{n}", n, n * 30000, vector,
|
|
"Legacy caption for frame" if n == 2
|
|
else "Old member caption",
|
|
),
|
|
)
|
|
con.execute(
|
|
"""INSERT INTO caption_windows (
|
|
id, media_id, start_ms, end_ms,
|
|
representative_frame_id, caption, window_policy
|
|
) VALUES ('cw1', 'm1', 0, 60000, 'f0',
|
|
'Wrong colour on shirt', 'test-policy')"""
|
|
)
|
|
con.executemany(
|
|
"""INSERT INTO caption_window_frames
|
|
(window_id, frame_id, position) VALUES ('cw1', ?, ?)""",
|
|
[("f0", 0), ("f1", 1)],
|
|
)
|
|
|
|
def test_list_shows_canonical_windows_not_member_frame_captions(self) -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
db = Path(d) / "scenes.sqlite3"
|
|
self.seed(db)
|
|
first = captioned_media(db, "m1", limit=1)
|
|
self.assertEqual(first["media"]["title"], "Some Movie")
|
|
self.assertEqual(first["overview_status"], "none")
|
|
self.assertEqual(first["captions"][0]["kind"], "window")
|
|
self.assertEqual(first["captions"][0]["caption"], "Wrong colour on shirt")
|
|
self.assertTrue(first["has_more"])
|
|
second = captioned_media(db, "m1", offset=1, limit=1)
|
|
self.assertEqual(second["captions"][0]["kind"], "frame")
|
|
self.assertEqual(second["captions"][0]["caption"], "Legacy caption for frame")
|
|
self.assertFalse(second["has_more"])
|
|
|
|
def test_correct_window_updates_only_representative_frame_and_audits(self) -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
db = Path(d) / "scenes.sqlite3"
|
|
self.seed(db)
|
|
with connect(db) as con:
|
|
con.execute(
|
|
"""INSERT INTO jellyfin_overview_drafts (
|
|
media_id, jellyfin_item_id, overview, model,
|
|
caption_fingerprint, sampled_captions
|
|
) VALUES ('m1', 'jf-1', 'Outdated summary',
|
|
'model', 'hash', 2)"""
|
|
)
|
|
|
|
meili = Mock()
|
|
result = correct_caption(
|
|
db, kind="window", caption_id="cw1",
|
|
expected_caption="Wrong colour on shirt",
|
|
caption="A person wearing a blue shirt",
|
|
meili=meili,
|
|
)
|
|
self.assertTrue(result["synced"])
|
|
self.assertTrue(result["overview_draft_invalidated"])
|
|
self.assertFalse(result["overview_published"])
|
|
documents = meili.update_documents.call_args.args[0]
|
|
# Only one partial caption update; no vector or full-index rebuild.
|
|
self.assertEqual(len(documents), 1)
|
|
self.assertEqual(documents[0]["id"], "f0")
|
|
self.assertEqual(documents[0]["caption"], "A person wearing a blue shirt")
|
|
self.assertNotIn("_vectors", documents[0])
|
|
meili.update_documents.assert_called_once()
|
|
self.assertTrue(meili.update_documents.call_args.kwargs["wait"])
|
|
with connect(db) as con:
|
|
saved = con.execute("SELECT caption FROM caption_windows WHERE id = 'cw1'").fetchone()
|
|
audit = con.execute("SELECT * FROM caption_edit_history").fetchone()
|
|
draft_count = con.execute(
|
|
"SELECT COUNT(*) FROM jellyfin_overview_drafts"
|
|
).fetchone()[0]
|
|
sync = con.execute(
|
|
"SELECT meili_synced_at FROM frames WHERE id='f0'"
|
|
).fetchone()[0]
|
|
self.assertEqual(saved["caption"], "A person wearing a blue shirt")
|
|
self.assertEqual(audit["previous_caption"], "Wrong colour on shirt")
|
|
self.assertEqual(audit["corrected_caption"], saved["caption"])
|
|
self.assertEqual(draft_count, 0)
|
|
self.assertIsNotNone(sync)
|
|
self.assertTrue(captioned_media(db, "m1")["captions"][0]["manually_edited"])
|
|
|
|
def test_correct_legacy_frame_and_reject_window_members(self) -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
db = Path(d) / "scenes.sqlite3"
|
|
self.seed(db)
|
|
meili = Mock()
|
|
with self.assertRaises(LookupError):
|
|
correct_caption(
|
|
db, kind="frame", caption_id="f1",
|
|
expected_caption="Old member caption",
|
|
caption="Nope", meili=meili,
|
|
)
|
|
result = correct_caption(
|
|
db, kind="frame", caption_id="f2",
|
|
expected_caption="Legacy caption for frame",
|
|
caption="Corrected frame text", meili=meili,
|
|
)
|
|
self.assertTrue(result["changed"])
|
|
self.assertEqual(
|
|
meili.update_documents.call_args.args[0][0]["caption"],
|
|
"Corrected frame text",
|
|
)
|
|
|
|
def test_stale_save_and_empty_text_do_not_overwrite_original(self) -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
db = Path(d) / "scenes.sqlite3"
|
|
self.seed(db)
|
|
meili = Mock()
|
|
with self.assertRaisesRegex(RuntimeError, "changed since loading"):
|
|
correct_caption(
|
|
db, kind="window", caption_id="cw1",
|
|
expected_caption="Stale old text",
|
|
caption="New", meili=meili,
|
|
)
|
|
with self.assertRaisesRegex(ValueError, "cannot be empty"):
|
|
correct_caption(
|
|
db, kind="window", caption_id="cw1",
|
|
expected_caption="Wrong colour on shirt",
|
|
caption=" ", meili=meili,
|
|
)
|
|
with connect(db) as con:
|
|
self.assertEqual(
|
|
con.execute("SELECT COUNT(*) FROM caption_edit_history").fetchone()[0], 0,
|
|
)
|
|
meili.update_documents.assert_not_called()
|
|
|
|
def test_meili_failure_preserves_correction_for_later_catchup(self) -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
db = Path(d) / "scenes.sqlite3"
|
|
self.seed(db)
|
|
meili = Mock()
|
|
meili.update_documents.side_effect = RuntimeError("queue busy")
|
|
result = correct_caption(
|
|
db, kind="window", caption_id="cw1",
|
|
expected_caption="Wrong colour on shirt",
|
|
caption="Blue shirt", meili=meili,
|
|
)
|
|
self.assertFalse(result["synced"])
|
|
self.assertIn("queue busy", result["sync_error"])
|
|
with connect(db) as con:
|
|
self.assertEqual(
|
|
con.execute("SELECT caption FROM caption_windows").fetchone()[0],
|
|
"Blue shirt",
|
|
)
|
|
self.assertIsNone(
|
|
con.execute("SELECT meili_synced_at FROM frames WHERE id='f0'")
|
|
.fetchone()[0],
|
|
)
|
|
self.assertEqual(
|
|
con.execute("SELECT COUNT(*) FROM caption_edit_history").fetchone()[0],
|
|
1,
|
|
)
|
|
|
|
def test_published_overview_is_preserved(self) -> None:
|
|
with tempfile.TemporaryDirectory() as d:
|
|
db = Path(d) / "scenes.sqlite3"
|
|
self.seed(db)
|
|
with connect(db) as con:
|
|
con.execute(
|
|
"""INSERT INTO jellyfin_overview_drafts (
|
|
media_id, jellyfin_item_id, overview, model,
|
|
caption_fingerprint, sampled_captions,
|
|
original_overview, applied_overview, applied_at
|
|
) VALUES ('m1', 'jf-1', 'Old draft',
|
|
'model', 'hash', 2, 'Original',
|
|
'Original + AI', CURRENT_TIMESTAMP)"""
|
|
)
|
|
result = correct_caption(
|
|
db, kind="window", caption_id="cw1",
|
|
expected_caption="Wrong colour on shirt",
|
|
caption="Blue shirt", meili=Mock(),
|
|
)
|
|
self.assertTrue(result["overview_published"])
|
|
self.assertFalse(result["overview_draft_invalidated"])
|
|
with connect(db) as con:
|
|
applied = con.execute(
|
|
"SELECT applied_overview FROM jellyfin_overview_drafts"
|
|
).fetchone()[0]
|
|
self.assertEqual(applied, "Original + AI")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|