@hybridlabor-api/aos 4.3.0 → 4.4.0

package/mcps/davinci-resolve-mcp/tests/test_sync_detection.py

@@ -1,213 +0,0 @@
-import math
-import os
-import shutil
-import struct
-import tempfile
-import unittest
-import wave
-
-from src.utils.sync_detection import (
-    analyze_samples_for_sync_events,
-    detect_sync_event_capabilities,
-    detect_sync_events_for_records,
-)
-from src.server import _apply_sync_event_markers
-
-
-def _synthetic_sync_samples(sample_rate=16000, duration_seconds=6.0):
-    samples = [0.0] * int(sample_rate * duration_seconds)
-
-    # One-frame 1 kHz 2-pop at 24 fps.
-    pop_start = int(2.0 * sample_rate)
-    pop_length = int((1.0 / 24.0) * sample_rate)
-    for index in range(pop_length):
-        samples[pop_start + index] = 0.75 * math.sin(2.0 * math.pi * 1000.0 * (index / sample_rate))
-
-    # Sharp slate-style impulse later in the file.
-    clap_start = int(4.0 * sample_rate)
-    samples[clap_start] = 0.95
-    samples[clap_start + 1] = -0.85
-    samples[clap_start + 3] = 0.55
-    return samples
-
-
-def _write_wav(path, samples, sample_rate=16000):
-    with wave.open(path, "wb") as handle:
-        handle.setnchannels(1)
-        handle.setsampwidth(2)
-        handle.setframerate(sample_rate)
-        frames = bytearray()
-        for sample in samples:
-            clipped = max(-1.0, min(1.0, sample))
-            frames.extend(struct.pack("<h", int(clipped * 32767)))
-        handle.writeframes(bytes(frames))
-
-
-class MarkerClipStub:
-    def __init__(self, clip_id, name):
-        self.clip_id = clip_id
-        self.name = name
-        self.markers = {}
-
-    def GetUniqueId(self):
-        return self.clip_id
-
-    def GetName(self):
-        return self.name
-
-    def AddMarker(self, frame, color, name, note, duration, custom_data=""):
-        self.markers[frame] = {
-            "color": color,
-            "name": name,
-            "note": note,
-            "duration": duration,
-            "customData": custom_data,
-        }
-        return True
-
-    def GetMarkerByCustomData(self, custom_data):
-        for marker in self.markers.values():
-            if marker.get("customData") == custom_data:
-                return marker
-        return {}
-
-    def DeleteMarkerByCustomData(self, custom_data):
-        for frame, marker in list(self.markers.items()):
-            if marker.get("customData") == custom_data:
-                del self.markers[frame]
-                return True
-        return False
-
-
-class FolderStub:
-    def __init__(self, clips=None, subfolders=None):
-        self.clips = clips or []
-        self.subfolders = subfolders or []
-
-    def GetClipList(self):
-        return self.clips
-
-    def GetSubFolderList(self):
-        return self.subfolders
-
-
-class MediaPoolStub:
-    def __init__(self, root):
-        self.root = root
-
-    def GetRootFolder(self):
-        return self.root
-
-
-class ProjectStub:
-    def __init__(self, media_pool):
-        self.media_pool = media_pool
-
-    def GetMediaPool(self):
-        return self.media_pool
-
-
-class SyncDetectionTests(unittest.TestCase):
-    def test_sample_detector_classifies_two_pop_and_slate_clap(self):
-        samples = _synthetic_sync_samples()
-        events = analyze_samples_for_sync_events(samples, 16000, fps=24.0)
-
-        two_pops = [event for event in events if event["type"] == "two_pop"]
-        claps = [event for event in events if event["type"] == "slate_clap"]
-
-        self.assertTrue(two_pops, events)
-        self.assertTrue(claps, events)
-        self.assertAlmostEqual(two_pops[0]["time_seconds"], 2.0, delta=0.04)
-        self.assertAlmostEqual(claps[0]["time_seconds"], 4.0, delta=0.04)
-        self.assertEqual(two_pops[0]["frame"], 48)
-
-    def test_capability_detection_never_installs(self):
-        caps = detect_sync_event_capabilities()
-
-        self.assertTrue(caps["success"])
-        self.assertTrue(caps["no_auto_install"])
-        self.assertIn("two_pop", caps["event_types"])
-        self.assertIn("slate_clap", caps["event_types"])
-
-    def test_events_include_marker_suggestions_requiring_confirmation(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = os.path.join(tmp, "camera_a.wav")
-            _write_wav(path, _synthetic_sync_samples())
-
-            result = detect_sync_events_for_records(
-                [{"clip_id": "clip-a", "clip_name": "camera_a.wav", "file_path": path, "fps": "24"}],
-                {"fps": 24, "scan_start_seconds": 6, "scan_tail_seconds": 0},
-            )
-
-        self.assertTrue(result["success"], result)
-        suggestions = result["files"][0]["marker_suggestions"]
-        self.assertTrue(suggestions)
-        self.assertTrue(suggestions[0]["requires_confirmation"])
-        self.assertTrue(suggestions[0]["eligible"])
-        self.assertEqual(suggestions[0]["scope"], "media_pool_item")
-        self.assertIn("mcp.sync_event", suggestions[0]["marker"]["custom_data"])
-
-    def test_marker_application_requires_confirmation(self):
-        detection = {
-            "files": [
-                {
-                    "marker_suggestions": [
-                        {
-                            "eligible": True,
-                            "clip_id": "clip-a",
-                            "clip_name": "camera_a.wav",
-                            "marker": {
-                                "frame": 48,
-                                "color": "Cyan",
-                                "name": "Sync: 2-pop",
-                                "note": "Detected 2-pop",
-                                "duration": 1,
-                                "custom_data": "mcp.sync_event:clip-a:two_pop:48",
-                            },
-                        }
-                    ]
-                }
-            ]
-        }
-        project = ProjectStub(MediaPoolStub(FolderStub([MarkerClipStub("clip-a", "camera_a.wav")])))
-
-        preview = _apply_sync_event_markers(project, detection, {})
-        self.assertFalse(preview["success"])
-        self.assertTrue(preview["confirmation_required"])
-
-        applied = _apply_sync_event_markers(project, detection, {"confirm": True})
-        self.assertTrue(applied["success"], applied)
-        self.assertEqual(applied["added"], 1)
-
-    @unittest.skipUnless(shutil.which("ffmpeg") and shutil.which("ffprobe"), "ffmpeg suite not installed")
-    def test_file_detector_returns_alignment_offsets(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            samples_a = _synthetic_sync_samples()
-            samples_b = [0.0] * int(0.25 * 16000) + samples_a
-            path_a = os.path.join(tmp, "camera_a.wav")
-            path_b = os.path.join(tmp, "camera_b.wav")
-            _write_wav(path_a, samples_a)
-            _write_wav(path_b, samples_b)
-
-            result = detect_sync_events_for_records(
-                [
-                    {"clip_name": "camera_a.wav", "file_path": path_a, "fps": "24"},
-                    {"clip_name": "camera_b.wav", "file_path": path_b, "fps": "24"},
-                ],
-                {
-                    "fps": 24,
-                    "scan_start_seconds": 6,
-                    "scan_tail_seconds": 0,
-                    "prefer_event_type": "two_pop",
-                },
-            )
-
-        self.assertTrue(result["success"], result)
-        suggestions = result["alignment"]["suggestions"]
-        self.assertEqual(len(suggestions), 2)
-        self.assertEqual(suggestions[0]["suggested_record_offset_frames"], 0)
-        self.assertEqual(suggestions[1]["suggested_record_offset_frames"], -6)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_thumbnail_image.py

@@ -1,55 +0,0 @@
-import base64
-import unittest
-
-from src.server import _thumbnail_data_to_png_bytes
-
-
-class ThumbnailImageTests(unittest.TestCase):
-    def test_rgb_thumbnail_converts_to_png(self):
-        raw_rgb = bytes([
-            255, 0, 0,
-            0, 255, 0,
-        ])
-        png = _thumbnail_data_to_png_bytes({
-            "width": 2,
-            "height": 1,
-            "noOfComponents": 3,
-            "depth": 8,
-            "data": base64.b64encode(raw_rgb).decode("ascii"),
-        })
-
-        self.assertTrue(png.startswith(b"\x89PNG\r\n\x1a\n"))
-        self.assertIn(b"IHDR", png)
-        self.assertIn(b"IDAT", png)
-        self.assertIn(b"IEND", png)
-
-    def test_rejects_short_thumbnail_data(self):
-        with self.assertRaisesRegex(ValueError, "too short"):
-            _thumbnail_data_to_png_bytes({
-                "width": 2,
-                "height": 1,
-                "noOfComponents": 3,
-                "depth": 8,
-                "data": base64.b64encode(b"\x00\x00\x00").decode("ascii"),
-            })
-
-    def test_rgba_thumbnail_uses_rgba_color_type(self):
-        raw_rgba = bytes([
-            255, 0, 0, 255,
-            0, 255, 0, 128,
-        ])
-        png = _thumbnail_data_to_png_bytes({
-            "width": 2,
-            "height": 1,
-            "noOfComponents": 4,
-            "depth": 8,
-            "data": raw_rgba,
-        })
-
-        # Color type is the tenth byte of IHDR data: 2 = RGB, 6 = RGBA.
-        ihdr_offset = png.index(b"IHDR") + 4
-        self.assertEqual(png[ihdr_offset + 9], 6)
-
-
-if __name__ == "__main__":
-    unittest.main()

package/mcps/davinci-resolve-mcp/tests/test_timeline_brain_db.py

@@ -1,230 +0,0 @@
-"""Unit tests for src/utils/timeline_brain_db.py (C6).
-
-No Resolve required.
-"""
-
-from __future__ import annotations
-
-import os
-import tempfile
-import unittest
-
-from src.utils import timeline_brain_db
-
-
-class TimelineBrainDB(unittest.TestCase):
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="brain_db_test_")
-        # `project_root` is the analysis project root; the DB lives under _soul/.
-        self.project_root = os.path.join(self.tmp, "project")
-        os.makedirs(self.project_root, exist_ok=True)
-
-    def tearDown(self) -> None:
-        timeline_brain_db.reset_for_test(self.project_root)
-        # Best-effort cleanup.
-        import shutil
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_db_file_created_at_expected_path(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        self.assertIsNotNone(conn)
-        expected = os.path.join(self.project_root, "_soul", "timeline_brain.sqlite")
-        self.assertTrue(os.path.isfile(expected), msg=f"missing: {expected}")
-
-    def test_schema_created(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        rows = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table' ORDER BY name"
-        ).fetchall()
-        names = {r["name"] for r in rows}
-        self.assertIn("timeline_versions", names)
-        self.assertIn("brain_edits", names)
-        self.assertIn("timeline_clip_usage", names)
-        self.assertIn("schema_metadata", names)
-
-    def test_schema_version_recorded(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        row = conn.execute(
-            "SELECT value FROM schema_metadata WHERE key='schema_version'"
-        ).fetchone()
-        self.assertEqual(row["value"], str(timeline_brain_db.SCHEMA_VERSION))
-
-    def test_insert_version_and_latest_version(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        self.assertIsNone(timeline_brain_db.latest_version(conn, "MyEdit"))
-        with timeline_brain_db.transaction(self.project_root) as txn:
-            txn.execute(
-                "INSERT INTO timeline_versions(timeline_name, version, created_at, archived_timeline_name, archived_bin_path) "
-                "VALUES (?, ?, ?, ?, ?)",
-                ("MyEdit", 1, "2026-05-26T00:00:00Z", "MyEdit_archived_v01", "Master/Archive"),
-            )
-            txn.execute(
-                "INSERT INTO timeline_versions(timeline_name, version, created_at, archived_timeline_name, archived_bin_path) "
-                "VALUES (?, ?, ?, ?, ?)",
-                ("MyEdit", 2, "2026-05-26T00:01:00Z", "MyEdit_archived_v02", "Master/Archive"),
-            )
-        self.assertEqual(timeline_brain_db.latest_version(conn, "MyEdit"), 2)
-        self.assertIsNone(timeline_brain_db.latest_version(conn, "Different"))
-
-    def test_run_archived_for_run_is_idempotent(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        run_id = "run_xyz"
-        self.assertFalse(timeline_brain_db.run_archived_for_run(conn, "Edit", run_id))
-        with timeline_brain_db.transaction(self.project_root) as txn:
-            txn.execute(
-                "INSERT INTO timeline_versions(timeline_name, version, created_at, analysis_run_id, archived_timeline_name, archived_bin_path) "
-                "VALUES (?, ?, ?, ?, ?, ?)",
-                ("Edit", 1, "2026-05-26T00:00:00Z", run_id, "Edit_archived_v01", "Master/Archive"),
-            )
-        self.assertTrue(timeline_brain_db.run_archived_for_run(conn, "Edit", run_id))
-        self.assertFalse(
-            timeline_brain_db.run_archived_for_run(conn, "Edit", "other_run"),
-            msg="A different run should not be marked archived",
-        )
-
-    def test_transaction_rolls_back_on_exception(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        try:
-            with timeline_brain_db.transaction(self.project_root) as txn:
-                txn.execute(
-                    "INSERT INTO timeline_versions(timeline_name, version, created_at, archived_timeline_name, archived_bin_path) "
-                    "VALUES (?, ?, ?, ?, ?)",
-                    ("Rollback", 1, "2026-05-26T00:00:00Z", "X", "Master/Archive"),
-                )
-                raise RuntimeError("simulated")
-        except RuntimeError:
-            pass
-        row = conn.execute(
-            "SELECT 1 FROM timeline_versions WHERE timeline_name='Rollback'"
-        ).fetchone()
-        self.assertIsNone(row, msg="rolled-back transaction left rows behind")
-
-
-class SchemaMigrations(unittest.TestCase):
-    """Verify the migration runner advances older DBs to SCHEMA_VERSION."""
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="brain_migration_test_")
-        self.project_root = os.path.join(self.tmp, "project")
-        os.makedirs(self.project_root, exist_ok=True)
-        self.saved_migrations = dict(timeline_brain_db._MIGRATIONS)
-        self.saved_version = timeline_brain_db.SCHEMA_VERSION
-
-    def tearDown(self) -> None:
-        timeline_brain_db.reset_for_test(self.project_root)
-        timeline_brain_db._MIGRATIONS.clear()
-        timeline_brain_db._MIGRATIONS.update(self.saved_migrations)
-        timeline_brain_db.SCHEMA_VERSION = self.saved_version
-        import shutil
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_migration_advances_existing_db(self) -> None:
-        # First open: lands at current production SCHEMA_VERSION (whatever it is today).
-        conn = timeline_brain_db.connect(self.project_root)
-        base_version = timeline_brain_db._read_schema_version(conn)
-        self.assertEqual(base_version, self.saved_version)
-        # Close the connection cache so a "new process" re-opens.
-        timeline_brain_db.close_all()
-        # Register a synthetic future migration one version above current.
-        future = base_version + 1
-        applied: list[int] = []
-
-        @timeline_brain_db.register_migration(future)
-        def _future(conn: "timeline_brain_db.sqlite3.Connection") -> None:
-            if not timeline_brain_db._column_exists(conn, "brain_edits", "test_column"):
-                conn.execute("ALTER TABLE brain_edits ADD COLUMN test_column TEXT")
-            applied.append(future)
-
-        timeline_brain_db.SCHEMA_VERSION = future
-        conn2 = timeline_brain_db.connect(self.project_root)
-        self.assertEqual(applied, [future], msg="future migration should have run once")
-        self.assertEqual(timeline_brain_db._read_schema_version(conn2), future)
-        self.assertTrue(timeline_brain_db._column_exists(conn2, "brain_edits", "test_column"))
-
-    def test_migration_is_idempotent_on_reopen(self) -> None:
-        # Open a fresh DB at base version first.
-        conn = timeline_brain_db.connect(self.project_root)
-        base_version = timeline_brain_db._read_schema_version(conn)
-        timeline_brain_db.close_all()
-        # Register a synthetic future migration and bump the schema.
-        future = base_version + 1
-        calls: list[int] = []
-
-        @timeline_brain_db.register_migration(future)
-        def _future(conn: "timeline_brain_db.sqlite3.Connection") -> None:
-            calls.append(future)
-
-        timeline_brain_db.SCHEMA_VERSION = future
-        timeline_brain_db.connect(self.project_root)
-        timeline_brain_db.close_all()
-        # Reopen — migration should NOT re-run because schema_version is already at future.
-        timeline_brain_db.connect(self.project_root)
-        self.assertEqual(calls, [future], msg="migration ran more than once")
-
-
-class ConcurrencyHardening(unittest.TestCase):
-    """Verify busy_timeout PRAGMA + retry-on-busy in transaction()."""
-
-    def setUp(self) -> None:
-        self.tmp = tempfile.mkdtemp(prefix="brain_concurrency_test_")
-        self.project_root = os.path.join(self.tmp, "project")
-        os.makedirs(self.project_root, exist_ok=True)
-
-    def tearDown(self) -> None:
-        timeline_brain_db.reset_for_test(self.project_root)
-        import shutil
-        shutil.rmtree(self.tmp, ignore_errors=True)
-
-    def test_busy_timeout_pragma_is_set(self) -> None:
-        conn = timeline_brain_db.connect(self.project_root)
-        row = conn.execute("PRAGMA busy_timeout").fetchone()
-        self.assertEqual(int(row[0]), timeline_brain_db.BUSY_TIMEOUT_MS)
-
-    def test_transaction_retries_when_lock_briefly_held(self) -> None:
-        """Hold a write lock for ~120ms from a second connection; transaction() should retry past it."""
-        import sqlite3 as _sqlite3
-        import threading as _threading
-
-        # Make sure the DB exists.
-        timeline_brain_db.connect(self.project_root)
-        db_path = timeline_brain_db.db_path_for_project(self.project_root)
-
-        lock_held = _threading.Event()
-        release = _threading.Event()
-
-        def hold_lock() -> None:
-            other = _sqlite3.connect(db_path, isolation_level=None)
-            other.execute(f"PRAGMA busy_timeout={timeline_brain_db.BUSY_TIMEOUT_MS}")
-            other.execute("BEGIN IMMEDIATE")
-            lock_held.set()
-            release.wait(timeout=2.0)
-            other.execute("COMMIT")
-            other.close()
-
-        t = _threading.Thread(target=hold_lock)
-        t.start()
-        lock_held.wait(timeout=1.0)
-        # Schedule release after ~120ms so the busy_timeout/retry path triggers.
-        timer = _threading.Timer(0.12, release.set)
-        timer.start()
-        try:
-            with timeline_brain_db.transaction(self.project_root) as txn:
-                txn.execute(
-                    "INSERT INTO timeline_versions(timeline_name, version, created_at, archived_timeline_name, archived_bin_path) "
-                    "VALUES (?, ?, ?, ?, ?)",
-                    ("Concurrent", 1, "2026-05-26T00:00:00Z", "x", "Master/Archive"),
-                )
-        finally:
-            release.set()
-            t.join(timeout=3.0)
-            timer.cancel()
-
-        conn = timeline_brain_db.connect(self.project_root)
-        row = conn.execute(
-            "SELECT 1 FROM timeline_versions WHERE timeline_name='Concurrent'"
-        ).fetchone()
-        self.assertIsNotNone(row, msg="row didn't land after busy retry")
-
-
-if __name__ == "__main__":
-    unittest.main()