Как рассчитать видимые участки V1 с учетом перекрытий V2

import os
import sys
from pathlib import Path


def import_resolve_module():
    try:
        import DaVinciResolveScript as dvr
        return dvr
    except ImportError:
        search_paths = [
            os.environ.get("RESOLVE_SCRIPT_API", ""),
            os.environ.get("RESOLVE_MODULES", ""),
            r"C:\\ProgramData\\Blackmagic Design\\DaVinci Resolve\\Support\\Developer\\Scripting\\Modules",
            "/opt/resolve/Developer/Scripting/Modules",
            "/opt/BlackmagicDesign/DaVinciResolve/Developer/Scripting/Modules",
            "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules",
            str(Path.home() / "Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting/Modules"),
        ]
        for path in search_paths:
            if path and os.path.isdir(path) and path not in sys.path:
                sys.path.append(path)
        import DaVinciResolveScript as dvr
        return dvr


def safe_call(obj, name, *args, **kwargs):
    try:
        fn = getattr(obj, name, None)
        if callable(fn):
            return fn(*args, **kwargs)
    except Exception:
        return None
    return None


def get_project_and_timeline():
    dvr = import_resolve_module()
    resolve = dvr.scriptapp("Resolve")
    if not resolve:
        raise RuntimeError("DaVinci Resolve API недоступен")

    project_manager = safe_call(resolve, "GetProjectManager")
    project = safe_call(project_manager, "GetCurrentProject") if project_manager else None
    if not project:
        raise RuntimeError("Нет открытого проекта DaVinci Resolve")

    timeline = safe_call(project, "GetCurrentTimeline")
    if not timeline:
        raise RuntimeError("Нет активного Timeline")

    return resolve, project, timeline


def subtract_intervals(base_start: int, base_end: int, blockers: list[tuple[int, int]]) -> list[tuple[int, int]]:
    segments = [(base_start, base_end)]
    for block_start, block_end in blockers:
        next_segments = []
        for start, end in segments:
            if block_end <= start or block_start >= end:
                next_segments.append((start, end))
                continue
            if block_start > start:
                next_segments.append((start, min(block_start, end)))
            if block_end < end:
                next_segments.append((max(block_end, start), end))
        segments = next_segments
    return [(start, end) for start, end in segments if end > start]


def visible_v1_segments(timeline) -> list[dict]:
    v1_items = safe_call(timeline, "GetItemListInTrack", "video", 1) or []
    v2_items = safe_call(timeline, "GetItemListInTrack", "video", 2) or []
    blockers = [(int(safe_call(item, "GetStart") or 0), int(safe_call(item, "GetEnd") or 0)) for item in v2_items]

    result = []
    for item in v1_items:
        start = int(safe_call(item, "GetStart") or 0)
        end = int(safe_call(item, "GetEnd") or start)
        for visible_start, visible_end in subtract_intervals(start, end, blockers):
            result.append({
                "clip": safe_call(item, "GetName") or "",
                "visible_start": visible_start,
                "visible_end": visible_end,
                "duration": visible_end - visible_start,
            })
    return result


resolve, project, timeline = get_project_and_timeline()
for segment in visible_v1_segments(timeline):
    print(segment)