@hybridlabor-api/aos 4.3.0 → 4.4.1

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

@@ -1,250 +0,0 @@
-import os
-import tempfile
-import unittest
-
-from src.server import (
-    _prepare_render_job,
-    _probe_render_matrix,
-    _quick_export_capabilities,
-    _render_capabilities,
-    _render_job_lifecycle_probe,
-    _safe_quick_export,
-    _safe_set_render_settings,
-    _validate_render_settings_action,
-)
-
-
-class RenderProjectStub:
-    def __init__(self):
-        self.settings = {
-            "TargetDir": tempfile.gettempdir(),
-            "CustomName": "stub_render",
-            "SelectAllFrames": True,
-        }
-        self.format_codec = {"format": "mp4", "codec": "H.264"}
-        self.mode = 0
-        self.jobs = {}
-        self.deleted = []
-        self.quick_export_calls = []
-        self.codec_queries = []
-        self.resolution_queries = []
-
-    def AddRenderJob(self):
-        job_id = f"job-{len(self.jobs) + 1}"
-        self.jobs[job_id] = {"JobId": job_id, "Status": "Queued"}
-        return job_id
-
-    def DeleteRenderJob(self, job_id):
-        self.deleted.append(job_id)
-        return self.jobs.pop(job_id, None) is not None
-
-    def DeleteAllRenderJobs(self):
-        self.jobs.clear()
-        return True
-
-    def GetRenderJobList(self):
-        return list(self.jobs.values())
-
-    def GetRenderJobStatus(self, job_id):
-        return self.jobs.get(job_id, {"Status": "Missing"})
-
-    def StartRendering(self, *args):
-        return True
-
-    def StopRendering(self):
-        return None
-
-    def IsRenderingInProgress(self):
-        return False
-
-    def GetRenderFormats(self):
-        return {"mp4": "mp4", "QuickTime": "mov"}
-
-    def GetRenderCodecs(self, render_format):
-        self.codec_queries.append(render_format)
-        if render_format == "mp4":
-            return {"H.264": "H.264", "H.265": "H.265"}
-        if render_format == "mov":
-            return {
-                "Apple ProRes 422 LT": "ProRes422LT",
-                "Apple ProRes 422 HQ": "ProRes422HQ",
-            }
-        return {}
-
-    def GetRenderResolutions(self, render_format, codec):
-        self.resolution_queries.append((render_format, codec))
-        return [{"Width": 1920, "Height": 1080}]
-
-    def GetCurrentRenderFormatAndCodec(self):
-        return dict(self.format_codec)
-
-    def SetCurrentRenderFormatAndCodec(self, render_format, codec):
-        self.format_codec = {"format": render_format, "codec": codec}
-        return True
-
-    def GetCurrentRenderMode(self):
-        return self.mode
-
-    def SetCurrentRenderMode(self, mode):
-        self.mode = mode
-        return True
-
-    def GetRenderSettings(self):
-        return dict(self.settings)
-
-    def SetRenderSettings(self, settings):
-        self.settings.update(settings)
-        return True
-
-    def GetRenderPresetList(self):
-        return ["H.264 Master"]
-
-    def LoadRenderPreset(self, name):
-        return True
-
-    def SaveAsNewRenderPreset(self, name):
-        return True
-
-    def DeleteRenderPreset(self, name):
-        return True
-
-    def GetQuickExportRenderPresets(self):
-        return ["H.264 Master"]
-
-    def RenderWithQuickExport(self, preset, params):
-        self.quick_export_calls.append({"preset": preset, "params": params})
-        return {"Status": "Queued"}
-
-
-class RenderDeliverProbeTest(unittest.TestCase):
-    def test_render_capabilities_exposes_methods_and_guards(self):
-        capabilities = _render_capabilities(RenderProjectStub())
-
-        self.assertTrue(capabilities["methods"]["AddRenderJob"])
-        self.assertEqual(capabilities["format_count"], 2)
-        self.assertIn("TargetDir", capabilities["supported_settings"])
-        self.assertTrue(capabilities["guards"]["upload_disabled_for_safe_quick_export"])
-
-    def test_probe_render_matrix_collects_codecs_and_resolutions(self):
-        matrix = _probe_render_matrix(RenderProjectStub(), {"max_pairs": 2})
-
-        self.assertEqual(matrix["format_total"], 2)
-        self.assertEqual(matrix["pairs_probed"], 2)
-        self.assertEqual(matrix["matrix"][0]["codecs"][0]["resolution_count"], 1)
-
-    def test_probe_render_matrix_uses_render_format_id_for_display_name(self):
-        project = RenderProjectStub()
-
-        matrix = _probe_render_matrix(project, {"formats": ["QuickTime"]})
-
-        self.assertEqual(matrix["pairs_probed"], 2)
-        self.assertEqual(matrix["matrix"][0]["format"], "QuickTime")
-        self.assertEqual(matrix["matrix"][0]["extension"], "mov")
-        self.assertEqual(matrix["matrix"][0]["codecs"][0]["codec"], "ProRes422LT")
-        self.assertEqual(project.codec_queries, ["mov"])
-        self.assertEqual(project.resolution_queries[0], ("mov", "ProRes422LT"))
-
-    def test_validate_render_settings_requires_temp_target_when_requested(self):
-        result = _validate_render_settings_action(
-            {"settings": {"TargetDir": os.getcwd(), "SelectAllFrames": True}, "require_temp_target": True}
-        )
-
-        self.assertFalse(result["valid"])
-        self.assertIn("TargetDir must be under the system temp directory", result["errors"][0])
-
-    def test_safe_set_render_settings_reports_diff_and_restores(self):
-        project = RenderProjectStub()
-        result = _safe_set_render_settings(
-            project,
-            {
-                "settings": {"TargetDir": tempfile.gettempdir(), "CustomName": "deliver_probe"},
-                "require_temp_target": True,
-                "restore": True,
-            },
-        )
-
-        self.assertTrue(result["success"])
-        self.assertEqual(result["diff"]["matched"], ["CustomName", "TargetDir"])
-        self.assertTrue(result["restore_success"])
-
-    def test_prepare_render_job_adds_job_with_temp_target(self):
-        project = RenderProjectStub()
-        result = _prepare_render_job(
-            project,
-            {
-                "target_dir": tempfile.gettempdir(),
-                "custom_name": "deliver_job",
-                "format": "mp4",
-                "codec": "H.264",
-            },
-        )
-
-        self.assertTrue(result["success"])
-        self.assertEqual(result["job_id"], "job-1")
-        self.assertEqual(project.format_codec["format"], "mp4")
-
-    def test_prepare_render_job_normalizes_display_format_name(self):
-        project = RenderProjectStub()
-
-        result = _prepare_render_job(
-            project,
-            {
-                "target_dir": tempfile.gettempdir(),
-                "custom_name": "prores_lt_proxy",
-                "format": "QuickTime",
-                "codec": "ProRes422LT",
-            },
-        )
-
-        self.assertTrue(result["success"])
-        self.assertTrue(result["format_success"])
-        self.assertEqual(project.format_codec, {"format": "mov", "codec": "ProRes422LT"})
-
-    def test_render_job_lifecycle_probe_deletes_probe_job(self):
-        project = RenderProjectStub()
-        result = _render_job_lifecycle_probe(project, {"target_dir": tempfile.gettempdir()})
-
-        self.assertTrue(result["success"])
-        self.assertEqual(project.deleted, ["job-1"])
-        self.assertEqual(project.GetRenderJobList(), [])
-
-    def test_safe_quick_export_dry_run_forces_upload_off(self):
-        project = RenderProjectStub()
-        result = _safe_quick_export(
-            project,
-            {
-                "preset": "H.264 Master",
-                "target_dir": tempfile.gettempdir(),
-                "custom_name": "quick_export_probe",
-                "dry_run": True,
-            },
-        )
-
-        self.assertTrue(result["success"])
-        self.assertFalse(result["params"]["EnableUpload"])
-        self.assertEqual(project.quick_export_calls, [])
-
-    def test_safe_quick_export_requires_allow_render_for_execution(self):
-        project = RenderProjectStub()
-        result = _safe_quick_export(
-            project,
-            {
-                "preset": "H.264 Master",
-                "target_dir": tempfile.gettempdir(),
-                "custom_name": "quick_export_probe",
-            },
-        )
-
-        self.assertTrue(result["success"])
-        self.assertFalse(result["would_render"])
-        self.assertEqual(project.quick_export_calls, [])
-
-    def test_quick_export_capabilities_lists_presets(self):
-        capabilities = _quick_export_capabilities(RenderProjectStub())
-
-        self.assertEqual(capabilities["preset_count"], 1)
-        self.assertTrue(capabilities["guards"]["EnableUpload_forced_false"])
-
-
-if __name__ == "__main__":
-    unittest.main()

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

@@ -1,282 +0,0 @@
-#!/usr/bin/env python3
-"""Live tests for Resolve 20.x scripting additions.
-
-Creates a temporary Resolve project, imports synthetic media generated by the
-test, exercises additive Resolve 20 APIs, then restores the original project.
-"""
-
-import base64
-import json
-import math
-import os
-import shutil
-import struct
-import sys
-import time
-import wave
-
-sys.path.insert(
-    0,
-    "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules",
-)
-
-import DaVinciResolveScript as dvr  # noqa: E402
-
-
-PROJECT_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
-TMP_ROOT = os.path.join(PROJECT_ROOT, "tmp", "resolve20-live")
-TEST_PROJECT = f"_mcp_resolve20_api_{int(time.time())}"
-
-PNG_1X1 = (
-    "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAADUlEQVR4nGNgYGD4DwABBAEA"
-    "ghO+9wAAAABJRU5ErkJggg=="
-)
-
-
-results = {"pass": [], "fail": [], "skip": []}
-
-
-def print_connection_diagnostics():
-    print("ERROR: Cannot connect to DaVinci Resolve")
-    print(f"Python: {sys.executable} ({sys.version.split()[0]})")
-    print(f"DaVinciResolveScript: {getattr(dvr, '__file__', '<unknown>')}")
-    print(f"RESOLVE_SCRIPT_API={os.environ.get('RESOLVE_SCRIPT_API', '<unset>')}")
-    print(f"RESOLVE_SCRIPT_LIB={os.environ.get('RESOLVE_SCRIPT_LIB', '<unset>')}")
-    print(
-        "Check Resolve Studio Preferences > System > General > "
-        "External scripting using, set it to Local, then restart Resolve."
-    )
-
-
-def record(kind, name, value=""):
-    results[kind].append((name, str(value)[:160]))
-    print(f"  {kind.upper():5} {name}: {str(value)[:120]}")
-
-
-def run_live_check(name, fn=None, skip_reason=None, allow_false=True):
-    if skip_reason or fn is None:
-        record("skip", name, skip_reason or "no test function")
-        return None
-    try:
-        value = fn()
-        if value is False and not allow_false:
-            record("fail", name, "returned False")
-        else:
-            record("pass", name, value)
-        return value
-    except Exception as exc:
-        record("fail", name, f"{type(exc).__name__}: {exc}")
-        return None
-
-
-def write_wav(path, freq):
-    sample_rate = 48000
-    duration = 0.5
-    frames = int(sample_rate * duration)
-    with wave.open(path, "wb") as wav:
-        wav.setnchannels(1)
-        wav.setsampwidth(2)
-        wav.setframerate(sample_rate)
-        for i in range(frames):
-            value = int(12000 * math.sin(2 * math.pi * freq * i / sample_rate))
-            wav.writeframes(struct.pack("<h", value))
-
-
-def write_media_files(base_dir):
-    os.makedirs(base_dir, exist_ok=True)
-    image_path = os.path.join(base_dir, "resolve20_still.png")
-    wav_a = os.path.join(base_dir, "resolve20_a.wav")
-    wav_b = os.path.join(base_dir, "resolve20_b.wav")
-    with open(image_path, "wb") as handle:
-        handle.write(base64.b64decode(PNG_1X1))
-    write_wav(wav_a, 440)
-    write_wav(wav_b, 880)
-    return image_path, wav_a, wav_b
-
-
-def find_clip_by_path(clips, path):
-    want = os.path.abspath(path)
-    for clip in clips or []:
-        try:
-            clip_path = clip.GetClipProperty("File Path")
-        except Exception:
-            clip_path = ""
-        if clip_path and os.path.abspath(clip_path) == want:
-            return clip
-    return None
-
-
-def first_item(timeline, track_type):
-    count = timeline.GetTrackCount(track_type) or 0
-    for track_index in range(1, count + 1):
-        items = timeline.GetItemListInTrack(track_type, track_index) or []
-        if items:
-            return track_index, items[0]
-    return None, None
-
-
-def cleanup(pm, original_project_name):
-    try:
-        if original_project_name:
-            pm.LoadProject(original_project_name)
-    finally:
-        try:
-            pm.DeleteProject(TEST_PROJECT)
-        except Exception:
-            pass
-        shutil.rmtree(TMP_ROOT, ignore_errors=True)
-
-
-def main():
-    resolve = dvr.scriptapp("Resolve")
-    if not resolve:
-        print_connection_diagnostics()
-        return 1
-
-    print(f"Connected to {resolve.GetProductName()} {resolve.GetVersionString()}")
-    version = resolve.GetVersion() or [0]
-    if version[0] < 20:
-        print("ERROR: Resolve 20+ is required for this test")
-        return 1
-
-    pm = resolve.GetProjectManager()
-    original_project = pm.GetCurrentProject()
-    original_project_name = original_project.GetName() if original_project else None
-    if original_project_name == "Untitled Project" and os.environ.get("RESOLVE20_LIVE_ALLOW_UNTITLED") != "1":
-        print(
-            "ERROR: Current project is 'Untitled Project'. Save or close it first, "
-            "or set RESOLVE20_LIVE_ALLOW_UNTITLED=1 if this is a disposable empty project."
-        )
-        return 1
-
-    shutil.rmtree(TMP_ROOT, ignore_errors=True)
-    media_dir = os.path.join(TMP_ROOT, "media")
-    media_location = os.path.join(TMP_ROOT, "project-media")
-    os.makedirs(media_location, exist_ok=True)
-    image_path, wav_a, wav_b = write_media_files(media_dir)
-
-    project = None
-    try:
-        project = run_live_check(
-            "PM.CreateProject(mediaLocationPath)",
-            lambda: pm.CreateProject(TEST_PROJECT, media_location),
-            allow_false=False,
-        )
-        if not project:
-            return 1
-
-        mp = project.GetMediaPool()
-        clips = run_live_check(
-            "MediaPool.ImportMedia(resolve20 fixtures)",
-            lambda: mp.ImportMedia([image_path, wav_a, wav_b]),
-            allow_false=False,
-        )
-        if not clips:
-            return 1
-
-        image_clip = find_clip_by_path(clips, image_path) or clips[0]
-        audio_clip = find_clip_by_path(clips, wav_a)
-        replacement_audio = wav_b
-
-        timeline = run_live_check(
-            "MP.CreateTimelineFromClips(resolve20 fixtures)",
-            lambda: mp.CreateTimelineFromClips("_resolve20_api_timeline", clips),
-            allow_false=False,
-        )
-        if not timeline:
-            return 1
-        project.SetCurrentTimeline(timeline)
-
-        audio_track, audio_item = first_item(timeline, "audio")
-        video_track, video_item = first_item(timeline, "video")
-
-        run_live_check("Resolve.GetFairlightPresets", lambda: resolve.GetFairlightPresets())
-        presets = resolve.GetFairlightPresets() or []
-        preset_name = presets[0] if presets else "__missing_resolve20_test_preset__"
-        run_live_check(
-            "Project.ApplyFairlightPresetToCurrentTimeline",
-            lambda: project.ApplyFairlightPresetToCurrentTimeline(preset_name),
-        )
-
-        run_live_check(
-            "Project.SetRenderSettings subtitle keys",
-            lambda: project.SetRenderSettings(
-                {"ExportSubtitle": False, "SubtitleFormat": "BurnIn"}
-            ),
-        )
-
-        if audio_clip:
-            original_name = audio_clip.GetName()
-            run_live_check("MPI.SetName", lambda: audio_clip.SetName(f"{original_name}_renamed"))
-            audio_clip.SetName(original_name)
-            run_live_check(
-                "MPI.LinkFullResolutionMedia",
-                lambda: audio_clip.LinkFullResolutionMedia(replacement_audio),
-            )
-            run_live_check(
-                "MPI.ReplaceClipPreserveSubClip",
-                lambda: audio_clip.ReplaceClipPreserveSubClip(replacement_audio),
-            )
-            run_live_check("MPI.MonitorGrowingFile", lambda: audio_clip.MonitorGrowingFile())
-        else:
-            for name in (
-                "MPI.SetName",
-                "MPI.LinkFullResolutionMedia",
-                "MPI.ReplaceClipPreserveSubClip",
-                "MPI.MonitorGrowingFile",
-            ):
-                run_live_check(name, skip_reason="No imported audio clip")
-
-        if audio_track:
-            state = run_live_check(
-                "TL.GetVoiceIsolationState",
-                lambda: timeline.GetVoiceIsolationState(audio_track),
-            )
-            safe_state = state if isinstance(state, dict) else {"isEnabled": False, "amount": 0}
-            run_live_check(
-                "TL.SetVoiceIsolationState",
-                lambda: timeline.SetVoiceIsolationState(audio_track, safe_state),
-            )
-        else:
-            run_live_check("TL.GetVoiceIsolationState", skip_reason="No audio track")
-            run_live_check("TL.SetVoiceIsolationState", skip_reason="No audio track")
-
-        item_for_name = video_item or audio_item
-        if item_for_name:
-            original_item_name = item_for_name.GetName()
-            run_live_check("TI.SetName", lambda: item_for_name.SetName(f"{original_item_name}_renamed"))
-            item_for_name.SetName(original_item_name)
-        else:
-            run_live_check("TI.SetName", skip_reason="No timeline item")
-
-        if audio_item:
-            state = run_live_check("TI.GetVoiceIsolationState", lambda: audio_item.GetVoiceIsolationState())
-            safe_state = state if isinstance(state, dict) else {"isEnabled": False, "amount": 0}
-            run_live_check("TI.SetVoiceIsolationState", lambda: audio_item.SetVoiceIsolationState(safe_state))
-        else:
-            run_live_check("TI.GetVoiceIsolationState", skip_reason="No audio timeline item")
-            run_live_check("TI.SetVoiceIsolationState", skip_reason="No audio timeline item")
-
-        if video_item:
-            run_live_check("TI.ResetAllNodeColors", lambda: video_item.ResetAllNodeColors())
-        else:
-            run_live_check("TI.ResetAllNodeColors", skip_reason="No video timeline item")
-
-    finally:
-        cleanup(pm, original_project_name)
-
-    out_path = os.path.join(os.path.dirname(__file__), "test_resolve20_results.json")
-    with open(out_path, "w") as handle:
-        json.dump(results, handle, indent=2)
-
-    print("\n=== Results ===")
-    print(f"Pass: {len(results['pass'])}")
-    print(f"Fail: {len(results['fail'])}")
-    print(f"Skip: {len(results['skip'])}")
-    print(f"Results saved to {out_path}")
-
-    return 0 if not results["fail"] and not results["skip"] else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())