How to Apply V1 Source Resolution to Project and Render Settings

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 is unavailable")

    project_manager = resolve.GetProjectManager()
    project = project_manager.GetCurrentProject() if project_manager else None
    if not project:
        raise RuntimeError("No DaVinci Resolve project is open")

    timeline = project.GetCurrentTimeline()
    if not timeline:
        raise RuntimeError("No active Timeline")

    return resolve, project, timeline

import re


def parse_resolution(value) -> tuple[int, int] | None:
    if value is None:
        return None
    match = re.search(r"(\\d{3,5})\\s*[xX×]\\s*(\\d{3,5})", str(value))
    if not match:
        return None
    width, height = int(match.group(1)), int(match.group(2))
    if width < 320 or height < 240:
        return None
    return width, height


def clip_resolution_from_media_pool_item(media_pool_item) -> tuple[int, int] | None:
    if not media_pool_item:
        return None
    for key in ("Resolution", "Video Resolution", "Frame Resolution", "Image Resolution", "Format"):
        parsed = parse_resolution(safe_call(media_pool_item, "GetClipProperty", key))
        if parsed:
            return parsed
    props = safe_call(media_pool_item, "GetClipProperty") or {}
    if isinstance(props, dict):
        for value in props.values():
            parsed = parse_resolution(value)
            if parsed:
                return parsed
    return None


def detect_v1_source_resolution(timeline) -> tuple[int, int] | None:
    candidates = []
    for item in safe_call(timeline, "GetItemListInTrack", "video", 1) or []:
        media_pool_item = safe_call(item, "GetMediaPoolItem")
        resolution = clip_resolution_from_media_pool_item(media_pool_item)
        if resolution:
            candidates.append(resolution)
    return max(candidates, key=lambda item: item[0] * item[1]) if candidates else None


def apply_project_resolution_from_v1(project, timeline) -> dict:
    detected = detect_v1_source_resolution(timeline)
    if not detected:
        return {"applied": False, "reason": "resolution_not_detected"}

    width, height = detected
    applied_width = safe_call(project, "SetSetting", "timelineResolutionWidth", str(width))
    applied_height = safe_call(project, "SetSetting", "timelineResolutionHeight", str(height))
    render_applied = safe_call(project, "SetRenderSettings", {"ResolutionWidth": width, "ResolutionHeight": height})

    return {"applied": bool(applied_width or applied_height or render_applied), "width": width, "height": height}


resolve, project, timeline = get_project_and_timeline()
print(apply_project_resolution_from_v1(project, timeline))