davinci-resolve-mcp 2.23.0

package/src/utils/project_properties.py

@@ -0,0 +1,601 @@
+#!/usr/bin/env python3
+"""
+DaVinci Resolve MCP Server - Project Properties Utilities
+
+This module provides functions for working with DaVinci Resolve project properties:
+- Getting and setting project settings
+- Managing project metadata
+- Handling project-specific configurations
+"""
+
+import os
+import logging
+import json
+from typing import Dict, List, Any, Optional, Union
+
+# Configure logging
+logger = logging.getLogger("davinci-resolve-mcp.project_properties")
+
+# Common project properties with their types
+PROJECT_PROPERTY_TYPES = {
+    # Timeline settings
+    "timelineFrameRate": "float",
+    "timelineResolutionWidth": "int",
+    "timelineResolutionHeight": "int",
+    "timelineOutputResolutionWidth": "int", 
+    "timelineOutputResolutionHeight": "int",
+    "timelineInterlaceProcessing": "int",
+    
+    # Color settings
+    "colorScienceMode": "int",
+    "timelineColorSpace": "string",
+    "timelineGamma": "string",
+    "inputDRT": "string",
+    "outputDRT": "string",
+    
+    # Image processing
+    "superScaleEnabled": "bool",
+    "superScaleQuality": "int",
+    "noiseReductionEnabled": "bool",
+    "noiseReductionMode": "int",
+    "noiseReductionValue": "float",
+    
+    # Format settings
+    "timelineAudioSampleRate": "int",
+    "timelineAudioBitDepth": "int",
+    "mediaPoolRelativePath": "bool",
+    
+    # Cache settings
+    "CacheMode": "int",
+    "CacheClipMode": "int",
+    "OptimizedMediaMode": "int",
+    "ProxyMode": "int",
+    "ProxyQuality": "int",
+    "TimelineCacheMode": "int",
+}
+
+def get_all_project_properties(project_obj) -> Dict[str, Any]:
+    """
+    Get all project properties and their values.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        
+    Returns:
+        Dictionary of all available project properties and their values
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        # Get all settings using empty string as key
+        all_settings = project_obj.GetSetting('')
+        
+        # Check if we got a valid response
+        if all_settings is None or not isinstance(all_settings, dict):
+            logger.warning("GetSetting('') did not return expected dictionary")
+            
+            # Fall back to getting known properties individually
+            properties = {}
+            for prop_name in PROJECT_PROPERTY_TYPES.keys():
+                try:
+                    value = project_obj.GetSetting(prop_name)
+                    properties[prop_name] = value
+                except Exception as e:
+                    logger.debug(f"Error getting property {prop_name}: {str(e)}")
+            
+            return properties
+        else:
+            # Return all settings
+            return all_settings
+            
+    except Exception as e:
+        logger.error(f"Error getting project properties: {str(e)}")
+        return {"error": f"Error getting project properties: {str(e)}"}
+
+def get_project_property(project_obj, property_name: str) -> Any:
+    """
+    Get a specific project property value.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        property_name: Name of the property to get
+        
+    Returns:
+        Value of the specified property or error information
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        # Get the specified property
+        value = project_obj.GetSetting(property_name)
+        
+        # Properly convert the value based on expected type
+        if property_name in PROJECT_PROPERTY_TYPES:
+            property_type = PROJECT_PROPERTY_TYPES[property_name]
+            
+            if property_type == "int" and not isinstance(value, int):
+                try:
+                    value = int(value)
+                except (ValueError, TypeError):
+                    # Keep Resolve's raw value when it cannot be safely coerced.
+                    pass
+            elif property_type == "float" and not isinstance(value, float):
+                try:
+                    value = float(value)
+                except (ValueError, TypeError):
+                    # Keep Resolve's raw value when it cannot be safely coerced.
+                    pass
+            elif property_type == "bool" and not isinstance(value, bool):
+                # Convert string representations of boolean
+                if isinstance(value, str):
+                    value = value.lower() in ("true", "yes", "1", "on")
+        
+        return value
+    except Exception as e:
+        logger.error(f"Error getting project property {property_name}: {str(e)}")
+        return {"error": f"Error getting project property: {str(e)}"}
+
+def set_project_property(project_obj, property_name: str, property_value: Any) -> bool:
+    """
+    Set a project property value.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        property_name: Name of the property to set
+        property_value: Value to set for the property
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    if project_obj is None:
+        return False
+    
+    try:
+        # Handle type conversion based on expected property type
+        if property_name in PROJECT_PROPERTY_TYPES:
+            property_type = PROJECT_PROPERTY_TYPES[property_name]
+            
+            if property_type == "int":
+                try:
+                    property_value = int(property_value)
+                except (ValueError, TypeError):
+                    logger.warning(f"Invalid integer value for property {property_name}: {property_value}")
+            
+            elif property_type == "float":
+                try:
+                    property_value = float(property_value)
+                except (ValueError, TypeError):
+                    logger.warning(f"Invalid float value for property {property_name}: {property_value}")
+            
+            elif property_type == "bool":
+                if isinstance(property_value, str):
+                    property_value = property_value.lower() in ("true", "yes", "1", "on")
+                property_value = bool(property_value)
+        
+        # Set the property
+        return project_obj.SetSetting(property_name, property_value)
+        
+    except Exception as e:
+        logger.error(f"Error setting project property {property_name}: {str(e)}")
+        return False
+
+def get_timeline_format_settings(project_obj) -> Dict[str, Any]:
+    """
+    Get timeline format settings for the project.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        
+    Returns:
+        Dictionary of timeline format settings
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        # Get relevant timeline format settings
+        settings = {}
+        format_properties = [
+            "timelineFrameRate", 
+            "timelineResolutionWidth", 
+            "timelineResolutionHeight",
+            "timelineOutputResolutionWidth",
+            "timelineOutputResolutionHeight",
+            "timelineInterlaceProcessing"
+        ]
+        
+        for prop in format_properties:
+            settings[prop] = get_project_property(project_obj, prop)
+        
+        # Add frame rate details
+        if "timelineFrameRate" in settings:
+            fps = settings["timelineFrameRate"]
+            
+            # Check if it's a drop frame rate
+            is_drop_frame = False
+            if isinstance(fps, (int, float)):
+                # Common drop frame rates: 29.97, 59.94
+                is_drop_frame = abs(fps - 29.97) < 0.01 or abs(fps - 59.94) < 0.01
+            
+            settings["isDropFrame"] = is_drop_frame
+        
+        # Add resolution name if standard
+        if "timelineResolutionWidth" in settings and "timelineResolutionHeight" in settings:
+            width = settings["timelineResolutionWidth"]
+            height = settings["timelineResolutionHeight"]
+            
+            # Determine common resolution names
+            resolution_name = None
+            if width == 3840 and height == 2160:
+                resolution_name = "UHD 4K"
+            elif width == 1920 and height == 1080:
+                resolution_name = "FHD 1080p"
+            elif width == 1280 and height == 720:
+                resolution_name = "HD 720p"
+            elif width == 4096 and height in [2160, 2304]:
+                resolution_name = "DCI 4K"
+            elif width == 2048 and height in [1080, 1152]:
+                resolution_name = "DCI 2K"
+            
+            if resolution_name:
+                settings["resolutionName"] = resolution_name
+        
+        return settings
+        
+    except Exception as e:
+        logger.error(f"Error getting timeline format settings: {str(e)}")
+        return {"error": f"Error getting timeline format settings: {str(e)}"}
+
+def set_timeline_format(project_obj, width: int, height: int, frame_rate: float, 
+                       interlaced: bool = False) -> bool:
+    """
+    Set timeline format (resolution and frame rate).
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        width: Timeline width in pixels
+        height: Timeline height in pixels
+        frame_rate: Timeline frame rate
+        interlaced: Whether the timeline should use interlaced processing
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    if project_obj is None:
+        return False
+    
+    try:
+        # Set timeline format properties
+        success = True
+        
+        # Set resolution
+        if not set_project_property(project_obj, "timelineResolutionWidth", width):
+            success = False
+        
+        if not set_project_property(project_obj, "timelineResolutionHeight", height):
+            success = False
+        
+        # Set frame rate
+        if not set_project_property(project_obj, "timelineFrameRate", frame_rate):
+            success = False
+        
+        # Set interlaced processing
+        interlace_value = 1 if interlaced else 0
+        if not set_project_property(project_obj, "timelineInterlaceProcessing", interlace_value):
+            success = False
+        
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error setting timeline format: {str(e)}")
+        return False
+
+def get_superscale_settings(project_obj) -> Dict[str, Any]:
+    """
+    Get SuperScale settings for the project.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        
+    Returns:
+        Dictionary of SuperScale settings
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        # Get SuperScale settings
+        settings = {}
+        
+        # Check if SuperScale is enabled
+        superscale_enabled = get_project_property(project_obj, "superScaleEnabled")
+        settings["enabled"] = bool(superscale_enabled)
+        
+        # Get quality setting
+        quality = get_project_property(project_obj, "superScaleQuality")
+        settings["quality"] = quality
+        
+        # Translate quality number to descriptive name
+        quality_names = {
+            0: "Auto",
+            1: "Better Quality",  # Sharper but might have artifacts
+            2: "Smoother",        # Less sharp but fewer artifacts
+        }
+        
+        if quality in quality_names:
+            settings["qualityName"] = quality_names[quality]
+        
+        # Add additional SuperScale properties if available
+        for prop in ["superScaleOverrideWidth", "superScaleOverrideHeight"]:
+            value = get_project_property(project_obj, prop)
+            if value is not None:
+                settings[prop] = value
+        
+        return settings
+        
+    except Exception as e:
+        logger.error(f"Error getting SuperScale settings: {str(e)}")
+        return {"error": f"Error getting SuperScale settings: {str(e)}"}
+
+def set_superscale_settings(project_obj, enabled: bool, quality: int = 0) -> bool:
+    """
+    Set SuperScale settings for the project.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        enabled: Whether SuperScale is enabled
+        quality: SuperScale quality (0=Auto, 1=Better Quality, 2=Smoother)
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    if project_obj is None:
+        return False
+    
+    try:
+        # Validate quality value
+        if quality not in [0, 1, 2]:
+            logger.warning(f"Invalid SuperScale quality value: {quality}. Using 0 (Auto)")
+            quality = 0
+        
+        # Set SuperScale properties
+        success = True
+        
+        # Set enabled state
+        if not set_project_property(project_obj, "superScaleEnabled", enabled):
+            success = False
+        
+        # Set quality
+        if not set_project_property(project_obj, "superScaleQuality", quality):
+            success = False
+        
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error setting SuperScale settings: {str(e)}")
+        return False
+
+def get_color_settings(project_obj) -> Dict[str, Any]:
+    """
+    Get color science and color space settings for the project.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        
+    Returns:
+        Dictionary of color settings
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        # Get color-related settings
+        settings = {}
+        color_properties = [
+            "colorScienceMode",
+            "timelineColorSpace",
+            "timelineGamma",
+            "inputDRT",
+            "outputDRT"
+        ]
+        
+        for prop in color_properties:
+            value = get_project_property(project_obj, prop)
+            if value is not None:
+                settings[prop] = value
+        
+        # Translate colorScienceMode to descriptive name
+        if "colorScienceMode" in settings:
+            mode = settings["colorScienceMode"]
+            mode_names = {
+                0: "DaVinci YRGB",
+                1: "DaVinci YRGB Color Managed",
+                2: "ACEScct"
+            }
+            
+            if mode in mode_names:
+                settings["colorScienceName"] = mode_names[mode]
+        
+        return settings
+        
+    except Exception as e:
+        logger.error(f"Error getting color settings: {str(e)}")
+        return {"error": f"Error getting color settings: {str(e)}"}
+
+def set_color_science_mode(project_obj, mode: str) -> bool:
+    """
+    Set color science mode for the project.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        mode: Color science mode ('YRGB', 'YRGB Color Managed', 'ACEScct', or numeric value)
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    if project_obj is None:
+        return False
+    
+    try:
+        # Map string modes to numeric values
+        mode_values = {
+            "YRGB": 0,
+            "DaVinci YRGB": 0,
+            "YRGB Color Managed": 1,
+            "DaVinci YRGB Color Managed": 1,
+            "ACEScct": 2,
+            "ACES": 2
+        }
+        
+        # Get numeric value
+        mode_value = None
+        
+        if isinstance(mode, int) and 0 <= mode <= 2:
+            mode_value = mode
+        elif isinstance(mode, str):
+            mode_value = mode_values.get(mode)
+        
+        if mode_value is None:
+            logger.error(f"Invalid color science mode: {mode}")
+            return False
+        
+        # Set the color science mode
+        return set_project_property(project_obj, "colorScienceMode", mode_value)
+        
+    except Exception as e:
+        logger.error(f"Error setting color science mode: {str(e)}")
+        return False
+
+def set_color_space(project_obj, color_space: str, gamma: str = None) -> bool:
+    """
+    Set timeline color space and gamma.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        color_space: Timeline color space (e.g., 'Rec.709', 'DCI-P3 D65', 'Rec.2020')
+        gamma: Timeline gamma (e.g., 'Rec.709 Gamma', 'Gamma 2.4')
+        
+    Returns:
+        True if successful, False otherwise
+    """
+    if project_obj is None:
+        return False
+    
+    try:
+        success = True
+        
+        # Set timeline color space
+        if not set_project_property(project_obj, "timelineColorSpace", color_space):
+            success = False
+        
+        # Set gamma if provided
+        if gamma is not None:
+            if not set_project_property(project_obj, "timelineGamma", gamma):
+                success = False
+        
+        return success
+        
+    except Exception as e:
+        logger.error(f"Error setting color space: {str(e)}")
+        return False
+
+def get_project_metadata(project_obj) -> Dict[str, Any]:
+    """
+    Get project metadata.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        
+    Returns:
+        Dictionary of project metadata
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        metadata = {}
+        
+        # Add basic project info
+        metadata["name"] = project_obj.GetName()
+        
+        # Add project path if available
+        if hasattr(project_obj, "GetPath"):
+            metadata["path"] = project_obj.GetPath()
+        
+        # Get current timeline
+        current_timeline = project_obj.GetCurrentTimeline()
+        if current_timeline:
+            metadata["currentTimeline"] = current_timeline.GetName()
+            
+            # Add timeline count
+            timeline_count = project_obj.GetTimelineCount()
+            metadata["timelineCount"] = timeline_count
+        
+        # Add frame rate and resolution
+        format_settings = get_timeline_format_settings(project_obj)
+        if "error" not in format_settings:
+            metadata.update(format_settings)
+        
+        # Add color settings
+        color_settings = get_color_settings(project_obj)
+        if "error" not in color_settings:
+            metadata["colorSettings"] = color_settings
+        
+        # Add SuperScale settings
+        superscale_settings = get_superscale_settings(project_obj)
+        if "error" not in superscale_settings:
+            metadata["superScale"] = superscale_settings
+        
+        return metadata
+        
+    except Exception as e:
+        logger.error(f"Error getting project metadata: {str(e)}")
+        return {"error": f"Error getting project metadata: {str(e)}"}
+
+def get_project_info(project_obj) -> Dict[str, Any]:
+    """
+    Get comprehensive project information including settings and metadata.
+    
+    Args:
+        project_obj: Project object from DaVinci Resolve API
+        
+    Returns:
+        Dictionary with project information
+    """
+    if project_obj is None:
+        return {"error": "Invalid project object"}
+    
+    try:
+        # Get project name
+        project_name = project_obj.GetName()
+        
+        # Combine all project information
+        project_info = {
+            "name": project_name,
+            "metadata": get_project_metadata(project_obj),
+            "settings": get_all_project_properties(project_obj),
+            "timelines": []
+        }
+        
+        # Add timeline information
+        timeline_count = project_obj.GetTimelineCount()
+        current_timeline = project_obj.GetCurrentTimeline()
+        current_timeline_name = current_timeline.GetName() if current_timeline else None
+        
+        for i in range(1, timeline_count + 1):
+            timeline = project_obj.GetTimelineByIndex(i)
+            if timeline:
+                timeline_info = {
+                    "name": timeline.GetName(),
+                    "isCurrent": timeline.GetName() == current_timeline_name,
+                    "duration": timeline.GetEndFrame() - timeline.GetStartFrame() + 1
+                }
+                project_info["timelines"].append(timeline_info)
+        
+        return project_info
+        
+    except Exception as e:
+        logger.error(f"Error getting project info: {str(e)}")
+        return {"error": f"Error getting project info: {str(e)}"}