@hybridlabor-api/aos 4.2.0 → 4.4.0

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

@@ -1,229 +0,0 @@
-import tempfile
-import unittest
-from pathlib import Path
-
-from src.server import (
-    _build_relink_plan,
-    _compare_timeline_snapshots,
-    _conform_capabilities,
-    _detect_gaps_overlaps_from_snapshot,
-    _detect_missing_media_from_snapshot,
-    _export_timeline_checked,
-    _source_ranges_from_snapshot,
-    _timeline_conform_snapshot,
-    _timeline_export_spec,
-)
-
-
-class MediaPoolItemStub:
-    def __init__(self, name, item_id, file_path):
-        self.name = name
-        self.item_id = item_id
-        self.file_path = file_path
-
-    def GetName(self):
-        return self.name
-
-    def GetUniqueId(self):
-        return self.item_id
-
-    def GetClipProperty(self, key=""):
-        return {
-            "File Path": self.file_path,
-            "Type": "Video + Audio",
-            "Duration": "00:00:02:00",
-            "Status": "Offline" if self.file_path and not Path(self.file_path).exists() else "Online",
-        }
-
-
-class TimelineItemStub:
-    def __init__(self, name, item_id, start, end, source_start, track_type, track_index, media_pool_item):
-        self.name = name
-        self.item_id = item_id
-        self.start = start
-        self.end = end
-        self.source_start = source_start
-        self.track_type = track_type
-        self.track_index = track_index
-        self.media_pool_item = media_pool_item
-
-    def GetName(self):
-        return self.name
-
-    def GetUniqueId(self):
-        return self.item_id
-
-    def GetStart(self):
-        return self.start
-
-    def GetEnd(self):
-        return self.end
-
-    def GetDuration(self):
-        return self.end - self.start
-
-    def GetSourceStartFrame(self):
-        return self.source_start
-
-    def GetLeftOffset(self):
-        return self.source_start
-
-    def GetTrackTypeAndIndex(self):
-        return [self.track_type, self.track_index]
-
-    def GetMediaPoolItem(self):
-        return self.media_pool_item
-
-
-class TimelineStub:
-    def __init__(self, tracks):
-        self.tracks = tracks
-
-    def GetName(self):
-        return "Conform Stub"
-
-    def GetUniqueId(self):
-        return "timeline-1"
-
-    def GetStartFrame(self):
-        return 86400
-
-    def GetEndFrame(self):
-        return 86500
-
-    def GetStartTimecode(self):
-        return "01:00:00:00"
-
-    def GetTrackCount(self, track_type):
-        return len(self.tracks.get(track_type, {}))
-
-    def GetItemListInTrack(self, track_type, track_index):
-        return self.tracks.get(track_type, {}).get(track_index, [])
-
-    def GetMarkers(self):
-        return {}
-
-    def Export(self, path, export_type, export_subtype):
-        export_path = Path(path)
-        if str(path).endswith(".fcpxml"):
-            export_path.mkdir(parents=True, exist_ok=True)
-            (export_path / "Info.fcpxml").write_text("<fcpxml />", encoding="utf-8")
-            return True
-        export_path.write_text("export", encoding="utf-8")
-        return True
-
-
-class ResolveConstStub:
-    EXPORT_FCPXML_1_10 = 1010
-    EXPORT_NONE = 0
-
-
-class TimelineConformProbeTest(unittest.TestCase):
-    def _timeline(self, missing_path="/tmp/missing_source.mov"):
-        online = MediaPoolItemStub("A.mov", "mpi-a", __file__)
-        missing = MediaPoolItemStub("B.mov", "mpi-b", missing_path)
-        return TimelineStub(
-            {
-                "video": {
-                    1: [
-                        TimelineItemStub("A", "a1", 0, 10, 100, "video", 1, online),
-                        TimelineItemStub("B", "b1", 15, 25, 200, "video", 1, missing),
-                    ],
-                    2: [
-                        TimelineItemStub("C", "c1", 5, 18, 300, "video", 2, online),
-                    ],
-                },
-                "audio": {
-                    1: [
-                        TimelineItemStub("A.wav", "a2", 0, 10, 100, "audio", 1, online),
-                    ]
-                },
-            }
-        )
-
-    def test_capabilities_include_interchange_aliases(self):
-        caps = _conform_capabilities()
-
-        self.assertIn("fcpxml", caps["export_aliases"])
-        self.assertIn("interchange", caps["supported"])
-
-    def test_snapshot_and_gap_detection(self):
-        snapshot = _timeline_conform_snapshot(self._timeline())
-        gaps = _detect_gaps_overlaps_from_snapshot(snapshot)
-
-        self.assertEqual(snapshot["item_count"], 4)
-        self.assertEqual(gaps["gap_count"], 1)
-        self.assertEqual(gaps["gaps"][0]["duration"], 5)
-
-    def test_source_ranges_merge_by_source(self):
-        snapshot = _timeline_conform_snapshot(self._timeline())
-        report = _source_ranges_from_snapshot(snapshot, {"handles": 2})
-
-        self.assertTrue(report["ranges"])
-        first_key = next(iter(report["ranges"]))
-        self.assertLessEqual(report["ranges"][first_key][0][0], 100)
-
-    def test_compare_snapshots_reports_item_mismatch(self):
-        left = _timeline_conform_snapshot(self._timeline())
-        right = _timeline_conform_snapshot(
-            TimelineStub({"video": {1: [TimelineItemStub("Changed", "x", 0, 9, 100, "video", 1, None)]}})
-        )
-        diff = _compare_timeline_snapshots(left, right)
-
-        self.assertFalse(diff["match"])
-        self.assertGreater(diff["difference_count"], 0)
-
-    def test_export_spec_resolves_alias_constants(self):
-        spec = _timeline_export_spec({"format": "fcpxml"}, ResolveConstStub())
-
-        self.assertEqual(spec["export_type"], ResolveConstStub.EXPORT_FCPXML_1_10)
-        self.assertEqual(spec["export_subtype"], ResolveConstStub.EXPORT_NONE)
-
-    def test_export_checked_reports_directory_primary_file(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            path = str(Path(tmp) / "timeline.fcpxml")
-            result = _export_timeline_checked(
-                self._timeline(),
-                {"format": "fcpxml", "path": path, "require_temp_path": False},
-            )
-
-        self.assertTrue(result["success"])
-        self.assertTrue(result["is_directory"])
-        self.assertTrue(result["primary_file"].endswith("Info.fcpxml"))
-
-    def test_missing_media_and_relink_plan(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            missing_path = str(Path(tmp) / "offline" / "lost.mov")
-            replacement = Path(tmp) / "lost.mov"
-            replacement.write_text("replacement", encoding="utf-8")
-            timeline = self._timeline(missing_path=missing_path)
-            snapshot = _timeline_conform_snapshot(timeline)
-            missing = _detect_missing_media_from_snapshot(snapshot)
-            plan = _build_relink_plan(timeline, {"search_roots": [tmp]})
-
-        self.assertEqual(missing["missing_count"], 1)
-        self.assertEqual(missing["diagnosis"]["unique_media_pool_item_count"], 1)
-        self.assertEqual(missing["diagnosis"]["primary_cause"], "folder_not_found")
-        self.assertTrue(plan["success"])
-        self.assertEqual(plan["candidate_count"], 1)
-        self.assertEqual(plan["unique_missing_basename_count"], 1)
-
-    def test_relink_plan_skips_search_when_source_volume_is_missing(self):
-        with tempfile.TemporaryDirectory() as tmp:
-            replacement = Path(tmp) / "P1047043.MOV"
-            replacement.write_text("replacement", encoding="utf-8")
-            missing_path = "/Volumes/EOS_DIGITAL/DCIM/104_PANA/P1047043.MOV"
-            timeline = self._timeline(missing_path=missing_path)
-            plan = _build_relink_plan(timeline, {"search_roots": [tmp], "sanitized": True})
-
-        self.assertTrue(plan["success"])
-        self.assertTrue(plan["search_skipped"])
-        self.assertEqual(plan["skip_reason"], "missing_source_volume_not_mounted")
-        self.assertEqual(plan["candidate_count"], 0)
-        self.assertEqual(plan["diagnosis"]["primary_cause"], "volume_not_mounted")
-        self.assertEqual(plan["diagnosis"]["missing_volumes"][0]["volume_root_sanitized"], "/Volumes/EOS_DIGITAL/...")
-        self.assertNotIn(tmp, str(plan))
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,88 +0,0 @@
-import unittest
-
-from src.server import (
-    _contact_sheet_png_bytes,
-    _contact_sheet_sample_label,
-    _frame_id_to_timecode,
-    _story_spine_from_snapshot,
-)
-
-
-class TimelineEditorialHelperTests(unittest.TestCase):
-    def test_contact_sheet_adds_label_band(self):
-        raw = bytes([255, 0, 0] * 4)
-        samples = [{
-            "frame": 108000,
-            "timecode": "01:00:00:00",
-            "source": "marker",
-            "marker": {"name": "Premise"},
-            "thumbnail_rgb": (2, 2, raw),
-        }]
-
-        width, height, png = _contact_sheet_png_bytes(samples, columns=1, padding=2, label_height=12)
-
-        self.assertEqual(width, 6)
-        self.assertEqual(height, 18)
-        self.assertTrue(png.startswith(b"\x89PNG"))
-        self.assertIn("PREMISE", _contact_sheet_sample_label(samples[0], 1).upper())
-
-    def test_frame_id_to_timecode_uses_nominal_frame_rate(self):
-        self.assertEqual(_frame_id_to_timecode(108000, 29.97), "01:00:00:00")
-        self.assertEqual(_frame_id_to_timecode(108015, 29.97), "01:00:00:15")
-
-    def test_story_spine_sorts_markers_and_summarizes_tracks(self):
-        snapshot = {
-            "name": "Evidence Cut",
-            "id": "timeline-1",
-            "start_frame": 108000,
-            "end_frame": 108450,
-            "start_timecode": "01:00:00:00",
-            "markers": {
-                108300: {"name": "Button", "note": "final turn", "color": "Blue", "duration": 1},
-                108000: {"name": "Premise", "note": "setup", "color": "Green", "duration": 1},
-            },
-            "tracks": {
-                "video": {
-                    "tracks": [{
-                        "track_index": 1,
-                        "items": [{
-                            "timeline_item_id": "v1",
-                            "name": "Source",
-                            "start": 108000,
-                            "end": 108120,
-                            "source_start": 120,
-                            "source_end": 240,
-                            "media_pool_item_name": "Source.mov",
-                        }],
-                    }],
-                },
-                "audio": {
-                    "tracks": [{
-                        "track_index": 1,
-                        "items": [{
-                            "timeline_item_id": "a1",
-                            "name": "Source Audio",
-                            "start": 108000,
-                            "end": 108450,
-                            "source_start": 120,
-                            "source_end": 570,
-                            "media_pool_item_name": "Source.mov",
-                        }],
-                    }],
-                },
-                "subtitle": {"tracks": []},
-            },
-        }
-
-        report = _story_spine_from_snapshot(snapshot)
-
-        self.assertTrue(report["audio_spine"]["present"])
-        self.assertEqual(report["beats"][0]["name"], "Premise")
-        self.assertEqual(report["beats"][1]["name"], "Button")
-        self.assertEqual(report["audio_spine"]["audio_item_count"], 1)
-        self.assertEqual(report["audio_spine"]["video_item_count"], 1)
-        self.assertIn("Source.mov", report["source_ranges"]["ranges"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,59 +0,0 @@
-"""Regression test for the raw timeline.export enum-argument fix (v2.54.1).
-
-Timeline.Export needs resolved resolve.EXPORT_* enum *values*; the raw export
-action used to forward p["type"] as a string, which Resolve silently rejects (no
-file written). The action must now resolve friendly format names — and EXPORT_*
-constant names — to live enum values via _timeline_export_spec.
-"""
-import unittest
-from unittest import mock
-
-import src.server as s
-
-
-class FakeResolveExport:
-    EXPORT_FCPXML_1_10 = "__FCPXML__"
-    EXPORT_EDL = "__EDL__"
-    EXPORT_NONE = "__NONE__"
-
-
-class TimelineExportSpecTest(unittest.TestCase):
-    def test_friendly_format_resolves_to_enum_value(self):
-        spec = s._timeline_export_spec({"type": "fcpxml"}, FakeResolveExport())
-        self.assertEqual(spec["export_type"], "__FCPXML__")
-        self.assertEqual(spec["export_subtype"], "__NONE__")
-        # Never the raw string.
-        self.assertNotEqual(spec["export_type"], "fcpxml")
-
-    def test_export_constant_name_resolves(self):
-        spec = s._timeline_export_spec({"type": "EXPORT_EDL"}, FakeResolveExport())
-        self.assertEqual(spec["export_type"], "__EDL__")
-
-
-class TimelineExportActionTest(unittest.TestCase):
-    def _run_export(self, params):
-        fake_tl = mock.Mock()
-        fake_tl.Export.return_value = True
-        fake_proj = mock.Mock()
-        fake_proj.GetCurrentTimeline.return_value = fake_tl
-        with mock.patch.object(s, "_check", return_value=(mock.Mock(), fake_proj, None)), \
-             mock.patch.object(s, "get_resolve", return_value=FakeResolveExport()):
-            out = s.timeline("export", params)
-        return out, fake_tl
-
-    def test_action_passes_resolved_enum_not_string(self):
-        out, fake_tl = self._run_export({"path": "/tmp/out.fcpxml", "type": "fcpxml"})
-        path_arg, type_arg, subtype_arg = fake_tl.Export.call_args[0]
-        self.assertEqual(path_arg, "/tmp/out.fcpxml")
-        self.assertEqual(type_arg, "__FCPXML__")   # resolved, not "fcpxml"
-        self.assertEqual(subtype_arg, "__NONE__")
-        self.assertTrue(out["success"])
-        self.assertEqual(out["export_type"], "EXPORT_FCPXML_1_10")
-
-    def test_action_edl(self):
-        _, fake_tl = self._run_export({"path": "/tmp/out.edl", "type": "edl"})
-        self.assertEqual(fake_tl.Export.call_args[0][1], "__EDL__")
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,70 +0,0 @@
-import unittest
-
-from src.utils.timeline_kernel_probe import (
-    ProbeRecorder,
-    parse_api_class_methods,
-    parse_timeline_item_property_keys,
-    render_markdown_report,
-    values_match,
-)
-
-
-class TimelineKernelProbeHelpersTest(unittest.TestCase):
-    def test_parse_timeline_item_property_keys_preserves_doc_order(self):
-        api_text = '''
-Looking up Timeline item properties
-The supported keys with their accepted values are:
-  "Pan" : floating point values
-  "Tilt" : floating point values
-  "Pan" : duplicate entry
-  "Opacity" : floating point values
-Values beyond the range will be clipped
-'''
-
-        self.assertEqual(parse_timeline_item_property_keys(api_text), ["Pan", "Tilt", "Opacity"])
-
-    def test_parse_api_class_methods_stops_at_next_class(self):
-        api_text = """
-Timeline
-  GetTrackCount(trackType)                        --> int
-  DeleteClips([timelineItems], Bool)              --> Bool
-TimelineItem
-  GetName()                                       --> string
-"""
-
-        self.assertEqual(parse_api_class_methods(api_text, "Timeline"), ["GetTrackCount", "DeleteClips"])
-
-    def test_probe_recorder_counts_and_validates_status(self):
-        recorder = ProbeRecorder()
-
-        recorder.record("runtime", "Timeline.GetTrackCount", "supported")
-        recorder.record("runtime", "Timeline.SplitClip", "unsupported")
-
-        self.assertEqual(recorder.counts()["supported"], 1)
-        self.assertEqual(recorder.counts()["unsupported"], 1)
-        with self.assertRaises(ValueError):
-            recorder.record("runtime", "bad", "maybe")
-
-    def test_values_match_handles_booleans_and_numeric_tolerance(self):
-        self.assertTrue(values_match(1.0004, 1.0))
-        self.assertTrue(values_match(1, True))
-        self.assertFalse(values_match(0, True))
-        self.assertTrue(values_match("Normal", "Normal"))
-
-    def test_render_markdown_report_groups_records(self):
-        recorder = ProbeRecorder()
-        recorder.record("properties.video", "Pan", "supported", details={"read": 0, "write": True})
-        report = recorder.to_report(
-            {"timestamp_utc": "2026-05-09T12:00:00+00:00", "product": "Resolve", "version_string": "20.3"},
-            {"json": "/tmp/report.json"},
-        )
-
-        markdown = render_markdown_report(report)
-
-        self.assertIn("# Timeline Edit Kernel Capability Probe", markdown)
-        self.assertIn("### properties.video", markdown)
-        self.assertIn("`Pan`", markdown)
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,64 +0,0 @@
-import unittest
-
-from src.utils.timeline_title_text import (
-    candidate_title_property_keys,
-    escape_xml_text_body,
-    flatten_timeline_item_properties,
-    plain_to_minimal_styled_xml,
-    timeline_item_get_property_map,
-)
-
-
-class PropItemStub:
-    def __init__(self, props):
-        self._props = props
-
-    def GetProperty(self, key=""):
-        if key == "":
-            return dict(self._props)
-        return self._props.get(key)
-
-
-class NoArgPropertyMapStub:
-    def GetProperty(self, key=None):
-        if key is None:
-            return {"Styled Text": "<x/>", "Pan": 0.0}
-        if key == "":
-            return None
-        return None
-
-
-class TimelineTitleTextUtilsTest(unittest.TestCase):
-    def test_flatten(self):
-        self.assertEqual(flatten_timeline_item_properties({"a": 1}), {"a": 1})
-        self.assertEqual(flatten_timeline_item_properties(None), {})
-
-    def test_get_property_map(self):
-        item = PropItemStub({"Styled Text": "<x/>", "Pan": 0.0})
-        flat, err = timeline_item_get_property_map(item, lambda x: x)
-        self.assertIsNone(err)
-        self.assertIn("Styled Text", flat)
-
-    def test_get_property_map_prefers_documented_no_arg_call(self):
-        flat, err = timeline_item_get_property_map(NoArgPropertyMapStub(), lambda x: x)
-        self.assertIsNone(err)
-        self.assertIn("Styled Text", flat)
-
-    def test_plain_to_minimal_and_escape(self):
-        s = plain_to_minimal_styled_xml('a < b & c "d"')
-        self.assertNotIn("< b", s)
-        self.assertIn("&lt;", s)
-        self.assertEqual(escape_xml_text_body("&"), "&amp;")
-
-    def test_candidate_keys_order(self):
-        flat = {
-            "Pan": "0",
-            "Styled Text": '<x/>',
-            "Foo": "x" * 30,
-        }
-        keys = [r["key"] for r in candidate_title_property_keys(flat)]
-        self.assertEqual(keys[0], "Styled Text")
-
-
-if __name__ == "__main__":
-    unittest.main()