@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,254 +0,0 @@
-"""Unit tests for src/utils/shot_relationships.py (spec §4 — cross-shot
-relationships).
-
-No Resolve and no embedding backends required: per-shot visual vectors are
-written straight into the v10 embeddings table so the pairwise heuristics,
-the frame-pair confirmation payload, commit (confirm/reject/override +
-supersede), listing, and the panel block are all covered offline.
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-import tempfile
-import unittest
-from unittest import mock
-
-from src.utils import analysis_store, embeddings, shot_relationships, timeline_brain_db
-from src.utils import media_analysis as ma
-
-from tests.test_analysis_store import make_report
-
-
-class ShotRelationshipsBase(unittest.TestCase):
-    def setUp(self) -> None:
-        self.root = tempfile.mkdtemp(prefix="shot-rel-test-")
-        self.addCleanup(shutil.rmtree, self.root, True)
-        self.addCleanup(timeline_brain_db.close_all)
-        report_a = make_report()
-        self.clip_a = analysis_store.ingest_report(self.root, report_a, clip_dir="clip-a-aaaaaaaaaaaa")["clip_uuid"]
-        report_b = make_report()
-        report_b["clip"] = dict(report_b["clip"], clip_id="22222222-0000-0000-0000-000000000002",
-                                clip_name="Second Clip.mp4", file_path="/media/second clip.mp4", media_id="cccc-dddd")
-        self.clip_b = analysis_store.ingest_report(self.root, report_b, clip_dir="second-clip-mp4-bbbbbbbbbbbb")["clip_uuid"]
-        self.frames_dir = os.path.join(self.root, "frames-fake")
-        os.makedirs(self.frames_dir, exist_ok=True)
-        conn = timeline_brain_db.connect(self.root)
-        self.shots = {}  # (clip_uuid, shot_index) -> shot_uuid
-        for row in conn.execute("SELECT shot_uuid, clip_uuid, shot_index FROM shots"):
-            self.shots[(str(row["clip_uuid"]), int(row["shot_index"]))] = str(row["shot_uuid"])
-        # Every frame gets a path so frame-pair payloads resolve.
-        with timeline_brain_db.transaction(self.root) as txn:
-            for row in conn.execute("SELECT clip_uuid, frame_index FROM frames").fetchall():
-                path = os.path.join(self.frames_dir, f"{row['clip_uuid']}_{row['frame_index']}.jpg")
-                with open(path, "wb") as handle:
-                    handle.write(b"fake")
-                txn.execute(
-                    "UPDATE frames SET frame_path = ? WHERE clip_uuid = ? AND frame_index = ?",
-                    (path, row["clip_uuid"], row["frame_index"]),
-                )
-
-    def _add_shot_vector(self, clip_uuid: str, shot_index: int, vector: list) -> str:
-        shot_uuid = self.shots[(clip_uuid, shot_index)]
-        with timeline_brain_db.transaction(self.root) as txn:
-            txn.execute(
-                """
-                INSERT OR REPLACE INTO embeddings
-                    (entity_type, entity_uuid, embedding_kind, model_name, dimension,
-                     vector, content_hash, computed_at)
-                VALUES ('shot', ?, 'visual', 'fake:clip', ?, ?, 'h', '2026-06-10T00:00:00Z')
-                """,
-                (shot_uuid, len(vector), embeddings.pack_vector(vector)),
-            )
-        return shot_uuid
-
-    def _seed_vectors(self) -> None:
-        # Clip A: shots 1+3 near-identical (same_setup_as, gap 2); shot 2 at
-        # cosine ~0.8 to both neighbors (continues_from band).
-        self.a1 = self._add_shot_vector(self.clip_a, 1, [1.0, 0.0, 0.0, 0.0])
-        self.a2 = self._add_shot_vector(self.clip_a, 2, [0.8, 0.0, 0.6, 0.0])
-        self.a3 = self._add_shot_vector(self.clip_a, 3, [1.0, 0.2, 0.0, 0.0])
-        # Clip B: shot 1 near-identical to A1 with comparable duration
-        # (alt_take_of); shots 2+3 orthogonal (no candidates).
-        self.b1 = self._add_shot_vector(self.clip_b, 1, [1.0, 0.1, 0.0, 0.0])
-        self._add_shot_vector(self.clip_b, 2, [0.0, 0.0, 0.0, 1.0])
-        self._add_shot_vector(self.clip_b, 3, [0.0, 1.0, 0.0, 0.0])
-
-
-class DetectShotRelationshipsTests(ShotRelationshipsBase):
-    def test_requires_shot_embeddings(self) -> None:
-        result = shot_relationships.detect_shot_relationships(self.root)
-        self.assertFalse(result["success"])
-        self.assertIn("build_embeddings", result["error"])
-
-    def test_heuristics_produce_typed_candidates(self) -> None:
-        self._seed_vectors()
-        result = shot_relationships.detect_shot_relationships(self.root)
-        self.assertTrue(result["success"], result)
-        self.assertEqual(result["status"], "pending_host_analysis")
-        by_type = {}
-        for candidate in result["candidates"]:
-            by_type.setdefault(candidate["suggested_type"], []).append(candidate)
-        self.assertIn("same_setup_as", by_type)
-        self.assertIn("continues_from", by_type)
-        self.assertIn("alt_take_of", by_type)
-        # Every candidate carries a frame PAIR.
-        for candidate in result["candidates"]:
-            self.assertTrue(candidate["source_shot"]["frame_path"])
-            self.assertTrue(candidate["target_shot"]["frame_path"])
-        # continues_from is directional: the LATER shot is the source.
-        cont = by_type["continues_from"][0]
-        self.assertGreater(cont["source_shot"]["shot_index"], cont["target_shot"]["shot_index"])
-        # Transcript continuity evidence: make_report has a segment 4.0-9.5s
-        # spanning the shot 1|2 boundary at 5.2s.
-        cont_1_2 = [c for c in by_type["continues_from"]
-                    if c["target_shot"]["shot_index"] == 1 and c["source_shot"]["shot_index"] == 2]
-        self.assertTrue(cont_1_2)
-        self.assertTrue(any("transcript" in e for e in cont_1_2[0]["evidence"]))
-        # Estimate: two frames per candidate.
-        self.assertEqual(
-            result["estimate"]["estimated_vision_tokens"],
-            len(result["candidates"]) * 2 * ma.AVG_VISION_TOKENS_PER_FRAME,
-        )
-        self.assertEqual(result["commit_action"]["action"], "commit_shot_relationships")
-
-    def test_no_rows_written_before_commit(self) -> None:
-        self._seed_vectors()
-        shot_relationships.detect_shot_relationships(self.root)
-        conn = timeline_brain_db.connect(self.root)
-        self.assertEqual(conn.execute("SELECT COUNT(*) FROM shot_relationships").fetchone()[0], 0)
-
-    def test_caps_refusal_blocks(self) -> None:
-        self._seed_vectors()
-        refusal = {"success": False, "error": "over_day_cap", "caps_refusal": True}
-        with mock.patch.object(ma, "_check_caps_pre_call", return_value=refusal):
-            result = shot_relationships.detect_shot_relationships(self.root)
-        self.assertEqual(result, refusal)
-
-    def test_redetect_overwrites_state(self) -> None:
-        self._seed_vectors()
-        first = shot_relationships.detect_shot_relationships(self.root)
-        second = shot_relationships.detect_shot_relationships(self.root, max_candidates=1)
-        state = shot_relationships._read_state(self.root)
-        self.assertEqual(state["vision_token"], second["vision_token"])
-        self.assertEqual(len(state["candidates"]), 1)
-        self.assertNotEqual(first["vision_token"], second["vision_token"])
-
-
-class CommitShotRelationshipsTests(ShotRelationshipsBase):
-    def _detect(self):
-        self._seed_vectors()
-        return shot_relationships.detect_shot_relationships(self.root)
-
-    def test_commit_confirm_reject_and_override(self) -> None:
-        payload = self._detect()
-        candidates = payload["candidates"]
-        entries = []
-        for candidate in candidates:
-            entries.append({
-                "candidate_index": candidate["candidate_index"],
-                "verdict": "confirm" if candidate["suggested_type"] != "continues_from" else "reject",
-                "relationship_type": candidate["suggested_type"],
-                "confidence": "high",
-            })
-        # Override one same_setup_as to alt_take_of to prove overrides stick.
-        overridden = next(e for e in entries if e["relationship_type"] == "same_setup_as")
-        overridden["relationship_type"] = "alt_take_of"
-        result = shot_relationships.commit_shot_relationships(
-            self.root, relationships_payload={"relationships": entries},
-            vision_token=payload["vision_token"],
-        )
-        self.assertTrue(result["success"], result)
-        self.assertGreater(result["confirmed"], 0)
-        self.assertGreater(result["rejected"], 0)
-        listed = shot_relationships.list_shot_relationships(self.root)
-        self.assertEqual(listed["count"], result["confirmed"])
-        self.assertTrue(all(r["source"] == "vision_relationship_v1" for r in listed["relationships"]))
-        self.assertTrue(all(r["superseded_at"] is None for r in listed["relationships"]))
-
-    def test_recommit_supersedes_machine_rows(self) -> None:
-        payload = self._detect()
-        entry = [{"candidate_index": 1, "verdict": "confirm", "confidence": "medium"}]
-        shot_relationships.commit_shot_relationships(
-            self.root, relationships_payload=entry, vision_token=payload["vision_token"])
-        # Same candidate confirmed again (e.g. a re-run) → old row superseded.
-        payload2 = shot_relationships.detect_shot_relationships(self.root)
-        shot_relationships.commit_shot_relationships(
-            self.root, relationships_payload=entry, vision_token=payload2["vision_token"])
-        current = shot_relationships.list_shot_relationships(self.root)
-        every = shot_relationships.list_shot_relationships(self.root, include_superseded=True)
-        self.assertEqual(current["count"], 1)
-        self.assertEqual(every["count"], 2)
-
-    def test_token_mismatch_rejected(self) -> None:
-        self._detect()
-        result = shot_relationships.commit_shot_relationships(
-            self.root, relationships_payload=[{"candidate_index": 1, "verdict": "confirm"}],
-            vision_token="wrong-token",
-        )
-        self.assertFalse(result["success"])
-        self.assertIn("vision_token mismatch", result["error"])
-
-    def test_invalid_type_skipped(self) -> None:
-        payload = self._detect()
-        result = shot_relationships.commit_shot_relationships(
-            self.root,
-            relationships_payload=[{"candidate_index": 1, "verdict": "confirm",
-                                    "relationship_type": "cuts_well_to"}],
-            vision_token=payload["vision_token"],
-        )
-        self.assertTrue(result["success"])
-        self.assertEqual(result["confirmed"], 0)
-        self.assertEqual(len(result["skipped"]), 1)
-
-
-class ReadSurfacesTests(ShotRelationshipsBase):
-    def _confirm_all(self):
-        self._seed_vectors()
-        payload = shot_relationships.detect_shot_relationships(self.root)
-        entries = [{"candidate_index": c["candidate_index"], "verdict": "confirm"}
-                   for c in payload["candidates"]]
-        shot_relationships.commit_shot_relationships(
-            self.root, relationships_payload=entries, vision_token=payload["vision_token"])
-        return payload
-
-    def test_list_filters_by_clip_and_type(self) -> None:
-        self._confirm_all()
-        alt_only = shot_relationships.list_shot_relationships(
-            self.root, relationship_type="alt_take_of")
-        self.assertTrue(alt_only["count"] >= 1)
-        self.assertTrue(all(r["relationship_type"] == "alt_take_of" for r in alt_only["relationships"]))
-        for_clip_b = shot_relationships.list_shot_relationships(
-            self.root, clip_ref="22222222-0000-0000-0000-000000000002")
-        self.assertTrue(for_clip_b["count"] >= 1)
-        missing = shot_relationships.list_shot_relationships(self.root, clip_ref="nope")
-        self.assertFalse(missing["success"])
-
-    def test_relationships_for_shot_panel_block(self) -> None:
-        self._confirm_all()
-        conn = timeline_brain_db.connect(self.root)
-        block_a1 = shot_relationships.relationships_for_shot(conn, self.a1)
-        # A1 has same_setup_as with shot 3 (same clip → bare label) and an
-        # alt take in clip B (cross-clip → clip-qualified label).
-        self.assertIn("same_setup_as", block_a1)
-        self.assertIn("shot 3", block_a1["same_setup_as"])
-        self.assertIn("alt_take_of", block_a1)
-        self.assertTrue(any("Second Clip" in label for label in block_a1["alt_take_of"]))
-        # continues_from shows on the SOURCE (continuing) shot only.
-        block_a2 = shot_relationships.relationships_for_shot(conn, self.a2)
-        self.assertIn("continues_from", block_a2)
-        self.assertIn("shot 1", block_a2["continues_from"])
-        self.assertNotIn("continues_from", block_a1)
-
-    def test_confirmed_alt_take_shot_uuids_bidirectional(self) -> None:
-        self._confirm_all()
-        conn = timeline_brain_db.connect(self.root)
-        alts_of_a1 = shot_relationships.confirmed_alt_take_shot_uuids(conn, self.a1)
-        self.assertIn(self.b1, alts_of_a1)
-        alts_of_b1 = shot_relationships.confirmed_alt_take_shot_uuids(conn, self.b1)
-        self.assertIn(self.a1, alts_of_b1)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,311 +0,0 @@
-"""Wiring tests for the live server adapters: clip_where, lint, and the
-declarative spec executor. Uses an in-memory fake Resolve so no live app is
-needed. The pure cores are covered separately (test_project_spec / _lint /
-_clip_query / _structural_diff); these exercise the server.py glue."""
-import unittest
-
-from src import server
-
-
-# ── Fakes ────────────────────────────────────────────────────────────────────
-class FakeMPI:
-    def __init__(self, uid):
-        self._uid = uid
-
-    def GetUniqueId(self):
-        return self._uid
-
-    def GetName(self):
-        return f"media_{self._uid}"
-
-
-class FakeItem:
-    def __init__(self, start, end, name, mpi):
-        self._start, self._end, self._name = start, end, name
-        self._mpi = FakeMPI(mpi)
-
-    def GetStart(self):
-        return self._start
-
-    def GetEnd(self):
-        return self._end
-
-    def GetDuration(self):
-        return self._end - self._start
-
-    def GetName(self):
-        return self._name
-
-    def GetUniqueId(self):
-        return f"item_{self._name}"
-
-    def GetMediaPoolItem(self):
-        return self._mpi
-
-
-class FakeTimeline:
-    def __init__(self, name, tracks=None, settings=None, markers=None):
-        self.name = name
-        self._tracks = tracks or {}          # {("video",1): [FakeItem,...]}
-        self._settings = settings or {}
-        self._markers = markers or {}        # {frame: {color,...}}
-
-    def GetName(self):
-        return self.name
-
-    def GetTrackCount(self, tt):
-        return max([idx for (t, idx) in self._tracks if t == tt] + [0])
-
-    def GetItemListInTrack(self, tt, idx):
-        return self._tracks.get((tt, idx), [])
-
-    def GetSetting(self, key):
-        return self._settings.get(key)
-
-    def SetSetting(self, key, value):
-        self._settings[key] = value
-        return True
-
-    def GetMarkers(self):
-        return dict(self._markers)
-
-    def AddMarker(self, frame, color, name, note, duration, custom):
-        self._markers[frame] = {"color": color, "name": name, "note": note,
-                                "duration": duration, "customData": custom}
-        return True
-
-    def GetStartFrame(self):
-        return 0
-
-    def GetEndFrame(self):
-        return 100
-
-    def GetUniqueId(self):
-        return f"tl_{self.name}"
-
-    def GetStartTimecode(self):
-        return "01:00:00:00"
-
-
-class FakeFolder:
-    def __init__(self, name):
-        self.name = name
-        self.subfolders = []
-
-    def GetName(self):
-        return self.name
-
-    def GetSubFolderList(self):
-        return list(self.subfolders)
-
-
-class FakeMediaPool:
-    def __init__(self, project):
-        self._project = project
-        self._root = FakeFolder("Master")
-
-    def CreateEmptyTimeline(self, name):
-        tl = FakeTimeline(name)
-        self._project._timelines.append(tl)
-        return tl
-
-    def GetRootFolder(self):
-        return self._root
-
-    def AddSubFolder(self, parent, name):
-        folder = FakeFolder(name)
-        parent.subfolders.append(folder)
-        return folder
-
-
-class FakeProject:
-    def __init__(self, name, timelines=None, settings=None):
-        self.name = name
-        self._timelines = timelines or []
-        self._settings = settings or {}
-        self._current = self._timelines[0] if self._timelines else None
-        self._mp = FakeMediaPool(self)
-
-    def GetName(self):
-        return self.name
-
-    def GetCurrentTimeline(self):
-        return self._current
-
-    def GetTimelineCount(self):
-        return len(self._timelines)
-
-    def GetTimelineByIndex(self, i):
-        return self._timelines[i - 1] if 1 <= i <= len(self._timelines) else None
-
-    def GetSetting(self, key):
-        return self._settings.get(key)
-
-    def SetSetting(self, key, value):
-        self._settings[key] = value
-        return True
-
-    def GetMediaPool(self):
-        return self._mp
-
-    def GetCurrentRenderFormatAndCodec(self):
-        return {"format": "mov", "codec": "ProRes422"}
-
-
-class FakePM:
-    def __init__(self, project, projects=None):
-        self._project = project
-        self._projects = projects or ([project.GetName()] if project else [])
-
-    def GetCurrentProject(self):
-        return self._project
-
-    def GetProjectListInCurrentFolder(self):
-        return list(self._projects)
-
-    def CreateProject(self, name):
-        self._project = FakeProject(name)
-        self._projects.append(name)
-        return self._project
-
-    def LoadProject(self, name):
-        return self._project
-
-
-class FakeResolve:
-    def __init__(self, pm):
-        self._pm = pm
-
-    def GetProjectManager(self):
-        return self._pm
-
-
-# ── Tests ────────────────────────────────────────────────────────────────────
-class ClipWhereWiringTest(unittest.TestCase):
-    def _timeline(self):
-        return FakeTimeline("Edit", tracks={
-            ("video", 1): [
-                FakeItem(0, 8, "INSERT_a", "mA"),
-                FakeItem(8, 248, "wide_master", "mB"),
-            ],
-            ("audio", 1): [FakeItem(0, 500, "room_tone", "mC")],
-        })
-
-    def test_duration_filter(self):
-        out = server._timeline_clip_where(self._timeline(), {"duration_lt": 12})
-        self.assertTrue(out["success"])
-        self.assertEqual(out["match_count"], 1)
-        self.assertEqual(out["clips"][0]["name"], "INSERT_a")
-        self.assertEqual(out["total_clips"], 3)
-
-    def test_track_type_filter(self):
-        out = server._timeline_clip_where(self._timeline(), {"track_type": "audio"})
-        self.assertEqual([c["name"] for c in out["clips"]], ["room_tone"])
-
-    def test_unknown_filter_rejected(self):
-        out = server._timeline_clip_where(self._timeline(), {"bogus": 1})
-        self.assertIn("error", out)
-        self.assertEqual(out["error"]["category"], "invalid_input")
-
-    def test_analysis_filter_not_live(self):
-        out = server._timeline_clip_where(self._timeline(), {"analyzed": True})
-        self.assertIn("error", out)
-        self.assertEqual(out["error"]["category"], "unsupported")
-
-
-class LintWiringTest(unittest.TestCase):
-    def test_lint_clean_project(self):
-        tl = FakeTimeline("Edit", tracks={("video", 1): [FakeItem(0, 10, "a", "m1")]},
-                          settings={"timelineFrameRate": "24"})
-        proj = FakeProject("Show", timelines=[tl], settings={"colorScienceMode": "acescct"})
-        out = server._project_lint_live(FakeResolve(FakePM(proj)), FakePM(proj))
-        self.assertTrue(out["success"])
-        self.assertEqual(out["counts"]["error"], 0)
-
-    def test_lint_no_project(self):
-        pm = FakePM(None, projects=[])
-        out = server._project_lint_live(FakeResolve(pm), pm)
-        codes = {i["code"] for i in out["issues"]}
-        self.assertIn("no_project", codes)
-
-    def test_lint_empty_timeline_warns(self):
-        tl = FakeTimeline("Edit", tracks={}, settings={"timelineFrameRate": "24"})
-        proj = FakeProject("Show", timelines=[tl])
-        pm = FakePM(proj)
-        out = server._project_lint_live(FakeResolve(pm), pm)
-        self.assertIn("empty_timeline", {i["code"] for i in out["issues"]})
-
-    def test_lint_audio_only_timeline_is_not_empty(self):
-        tl = FakeTimeline("Music", tracks={
-            ("audio", 1): [FakeItem(0, 240, "music_master", "m1")],
-        }, settings={"timelineFrameRate": "24"})
-        proj = FakeProject("Show", timelines=[tl])
-        pm = FakePM(proj)
-        out = server._project_lint_live(FakeResolve(pm), pm)
-        self.assertNotIn("empty_timeline", {i["code"] for i in out["issues"]})
-
-
-class SpecActionWiringTest(unittest.TestCase):
-    def test_diff_to_spec_inline(self):
-        proj = FakeProject("Show", timelines=[], settings={})
-        pm = FakePM(proj)
-        out = server._spec_action(FakeResolve(pm), pm, "diff_to_spec", {
-            "spec": {"project": "Show", "settings": {"timelineFrameRate": "24"}},
-        })
-        self.assertTrue(out["success"])
-        self.assertIn("actions", out)
-        self.assertGreaterEqual(out["change_count"], 1)  # fps setting differs
-
-    def test_apply_spec_creates_timeline_and_marker(self):
-        proj = FakeProject("Show", timelines=[], settings={})
-        pm = FakePM(proj)
-        out = server._spec_action(FakeResolve(pm), pm, "apply_spec", {
-            "spec": {
-                "project": "Show",
-                "timelines": [{"name": "Edit_v2", "fps": 24,
-                               "markers": [{"frame": 0, "color": "Blue", "name": "HEAD"}]}],
-            },
-        })
-        self.assertTrue(out["success"], out)
-        names = [tl.GetName() for tl in proj._timelines]
-        self.assertIn("Edit_v2", names)
-        new_tl = next(tl for tl in proj._timelines if tl.GetName() == "Edit_v2")
-        self.assertIn(0, new_tl.GetMarkers())
-
-    def test_apply_spec_creates_media_pool_bins(self):
-        proj = FakeProject("Show", timelines=[], settings={})
-        pm = FakePM(proj)
-        spec = {"project": "Show", "bins": ["Master/Media/Scene_01"]}
-
-        out = server._spec_action(FakeResolve(pm), pm, "apply_spec", {"spec": spec})
-
-        self.assertTrue(out["success"], out)
-        plan = server._spec_action(FakeResolve(pm), pm, "diff_to_spec", {"spec": spec})
-        self.assertEqual(plan["change_count"], 0, plan["actions"])
-
-    def test_apply_spec_idempotent_second_run(self):
-        proj = FakeProject("Show", timelines=[], settings={})
-        pm = FakePM(proj)
-        spec = {"project": "Show",
-                "timelines": [{"name": "E", "fps": 24, "markers": [{"frame": 0}]}]}
-        server._spec_action(FakeResolve(pm), pm, "apply_spec", {"spec": spec})
-        # Second run: plan should be all-noop.
-        plan = server._spec_action(FakeResolve(pm), pm, "diff_to_spec", {"spec": spec})
-        self.assertEqual(plan["change_count"], 0, plan["actions"])
-
-    def test_bad_spec_returns_invalid_input(self):
-        proj = FakeProject("Show")
-        pm = FakePM(proj)
-        out = server._spec_action(FakeResolve(pm), pm, "apply_spec", {"spec": {"no_project": 1}})
-        self.assertIn("error", out)
-        self.assertEqual(out["error"]["category"], "invalid_input")
-
-    def test_missing_spec_arg(self):
-        proj = FakeProject("Show")
-        pm = FakePM(proj)
-        out = server._spec_action(FakeResolve(pm), pm, "apply_spec", {})
-        self.assertEqual(out["error"]["code"], "NO_SPEC")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,45 +0,0 @@
-"""Static guard: no undefined names anywhere under src/.
-
-An undefined name inside a guard or try/except doesn't crash — it silently
-falls back to a default. Three shipped bugs were this class: the
-confirm-token gate calling a misspelled preference reader (v2.37.0), the
-update-channel resource reporting "stable" unconditionally, and the
-auto-run idle-timeout preference being ignored (both fixed after a
-pyflakes audit). This test keeps the class extinct.
-
-Skips when pyflakes is not installed (it is a dev dependency, not a
-runtime one): `pip install pyflakes`.
-"""
-from __future__ import annotations
-
-import io
-import pathlib
-import unittest
-
-try:
-    from pyflakes.api import checkPath
-    from pyflakes.reporter import Reporter
-    HAVE_PYFLAKES = True
-except ImportError:
-    HAVE_PYFLAKES = False
-
-SRC = pathlib.Path(__file__).resolve().parent.parent / "src"
-
-
-@unittest.skipUnless(HAVE_PYFLAKES, "pyflakes not installed")
-class UndefinedNamesTest(unittest.TestCase):
-    def test_no_undefined_names_in_src(self):
-        out = io.StringIO()
-        reporter = Reporter(out, out)
-        for path in sorted(SRC.rglob("*.py")):
-            checkPath(str(path), reporter)
-        undefined = [
-            line
-            for line in out.getvalue().splitlines()
-            if "undefined name" in line and "unable to detect undefined names" not in line
-        ]
-        self.assertEqual(undefined, [], "undefined names found:\n" + "\n".join(undefined))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,67 +0,0 @@
-"""Unit tests for the reusable structural diff engine (Phase A)."""
-import unittest
-
-from src.utils import structural_diff as sd
-
-
-class StructuralDiffTest(unittest.TestCase):
-    def test_identical_is_empty(self):
-        a = {"x": 1, "list": [{"id": 1, "v": "a"}]}
-        diff = sd.compare(a, dict(a, list=[{"id": 1, "v": "a"}]))
-        self.assertTrue(diff.is_empty())
-        self.assertEqual(diff.summary()["total"], 0)
-
-    def test_scalar_change(self):
-        diff = sd.compare({"fps": 24}, {"fps": 25})
-        self.assertEqual(diff.summary(), {"added": 0, "removed": 0, "changed": 1, "total": 1})
-        self.assertEqual(diff.changed()[0].before, 24)
-        self.assertEqual(diff.changed()[0].after, 25)
-        self.assertEqual(diff.changed()[0].path, "fps")
-
-    def test_added_and_removed_keys(self):
-        diff = sd.compare({"a": 1}, {"b": 2})
-        ops = {c.op for c in diff.changes}
-        self.assertEqual(ops, {"added", "removed"})
-
-    def test_list_keyed_alignment_detects_reorder_as_no_change(self):
-        # Same elements, different order, keyed by media_pool_item_id → no change.
-        left = [{"media_pool_item_id": "A", "v": 1}, {"media_pool_item_id": "B", "v": 2}]
-        right = [{"media_pool_item_id": "B", "v": 2}, {"media_pool_item_id": "A", "v": 1}]
-        diff = sd.compare({"clips": left}, {"clips": right})
-        self.assertTrue(diff.is_empty(), diff.to_dict())
-
-    def test_list_keyed_alignment_detects_field_change(self):
-        left = [{"id": "A", "grade": "x"}]
-        right = [{"id": "A", "grade": "y"}]
-        diff = sd.compare({"clips": left}, {"clips": right})
-        self.assertEqual(diff.summary()["changed"], 1)
-        self.assertIn("[id=A]", diff.changed()[0].path)
-
-    def test_list_keyed_add_remove(self):
-        left = [{"id": "A"}]
-        right = [{"id": "A"}, {"id": "B"}]
-        diff = sd.compare(left, right)
-        self.assertEqual(diff.summary()["added"], 1)
-        self.assertEqual(diff.added()[0].after, {"id": "B"})
-
-    def test_positional_fallback_when_no_shared_key(self):
-        diff = sd.compare([1, 2, 3], [1, 9, 3])
-        self.assertEqual(diff.summary()["changed"], 1)
-        self.assertEqual(diff.changed()[0].path, "[1]")
-
-    def test_clip_hash_takes_precedence_over_name(self):
-        # Renamed clip (same hash) is a change, not delete+add.
-        left = [{"clip_hash": "h1", "name": "old"}]
-        right = [{"clip_hash": "h1", "name": "new"}]
-        diff = sd.compare(left, right)
-        self.assertEqual(diff.summary()["changed"], 1)
-        self.assertIn("[clip_hash=h1]", diff.changed()[0].path)
-
-    def test_to_dict_shape(self):
-        d = sd.compare({"a": 1}, {"a": 2}).to_dict()
-        self.assertEqual(set(d), {"left_label", "right_label", "summary", "changes"})
-        self.assertEqual(d["changes"][0]["op"], "changed")
-
-
-if __name__ == "__main__":
-    unittest.main()