code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Unreal

Sequence Builder

Jorge Hernandez Ibañez 25/08/2025

Tags

Sequence Builder

Jorge Herna…

Action v1

25/08/2025

Unreal

Pseudo-Code

Parameters

shot_tasks

The list of tasks that can be loaded and created in Unreal. Must match the task code name.

Talk with TD Support

Import to my Pipeline

Code

import os
import pipelinepro as pipeline
import ast

try:
    import unreal
    UNREAL_AVAILABLE = True
except ImportError:
    UNREAL_AVAILABLE = False
    print("Unreal Engine Python API not available")

# Global inputs

shot_tasks = ["layout", "animation", "light"]

# General utils

def get_task_last_folder(task_key, folder_type):
    query = """
    query{
        lastFolderByTask(taskKey:"{task_key}", type:"{folder_type}", token: "{token}"){
            name
            code
            review
            wip
            files{
                fileName
                pathToFile
                fileLocal
                key
                data
                folder{
                    name
                    review
                    wip
                    dependence{
                        review
                        wip
                    }
                }
            }
        }
    }
    """
    query = query.replace("{task_key}", task_key)
    query = query.replace("{folder_type}", folder_type)

response = pipeline.query(query)
    if not response or 'errors' in response:
        return []
    return response.get('lastFolderByTask', {})

# Load cameras code

def load_task_cameras(task_key, level_sequence, shot_folder):
    """
    Load camera FBX files into Unreal project and add them to the level sequence.
    
    Args:
        task_key (str): The task key to get camera files from
        level_sequence: The Unreal level sequence to add cameras to
        shot_folder (str): The shot folder path where cameras should be imported
                              (e.g., "/Game/Episodes/ep101/sq001/shots/sh0010/")
    
    Returns:
        list: List of imported camera bindings
    """
    if not UNREAL_AVAILABLE:
        print("Cannot load cameras: Unreal Engine API not available")
        return []
    
    folder = get_task_last_folder(task_key, "cameras")
    if not folder:
        print(f"No camera folder found for task: {task_key}")
        return []

# Load camera files
    camera_files = []
    for file in folder.get('files', []):
        if file.get('fileName', '').endswith('.fbx'):
            camera_files.append(file)

if not camera_files:
        print(f"No FBX camera files found for task: {task_key}")
        return []

imported_cameras = []
    
    # Get the world context
    world = unreal.EditorLevelLibrary.get_editor_world()
    if not world:
        print("Could not get editor world")
        return []
    
    # Process each camera file
    for camera_file in camera_files:
        file_path = camera_file.get('pathToFile')
        file_name = camera_file.get('fileName')
        # Get cache data for import
        camera_data = camera_file.get("data")
        camera_name = os.path.splitext(file_name)[0]
        print(f"Camera file data: {camera_data}")
        if camera_data:
            try:
                camera_data = ast.literal_eval(camera_data).get("camera", {})
                # Camera Name
                camera_name = camera_data.get("camera", camera_name)
            except (ValueError, SyntaxError) as e:
                print(f"Error parsing cache data for cache data from {file_name}: {e}")
        
        if not file_path or not os.path.exists(file_path):
            print(f"Camera file not found: {file_path}")
            continue
        
        try:
            # Get source key for metadata (use file key if available)
            source_key = camera_file.get("key", camera_file.get("id", file_name))
            
            # Import FBX and create spawnable cameras with metadata support
            camera_spawnable = import_camera_fbx_to_sequence(
                world, 
                level_sequence, 
                file_path, 
                camera_name, 
                asset_path=shot_folder,
                camera_file=camera_file,
                source_key=source_key
            )
            if camera_spawnable:
                print(f"Successfully imported camera as spawnable: {camera_name}")
                imported_cameras.append(camera_spawnable)
            else:
                print(f"Failed to import camera as spawnable: {camera_name}")
                
        except Exception as e:
            print(f"Error importing camera {file_name}: {e}")
    
    return imported_cameras

def find_existing_binding(level_sequence, target_name):
    """
    Find an existing camera binding by name.
    
    Args:
        level_sequence: The level sequence to search in
        camera_name (str): Name of the camera to find
    
    Returns:
        MovieSceneBindingProxy or None: The existing binding if found
    """
    bindings = level_sequence.get_bindings()
    
    for binding in bindings:
        binding_name = str(binding.get_display_name())
        if binding_name == target_name:
            return binding
    
    return None

def remove_binding_and_children_recursive(binding):
    """
    Remove a binding and all its child bindings recursively.
    
    Args:
        binding: The MovieSceneBindingProxy to remove with its children
    """
    try:
        # Get all child possessables first
        child_possessables = binding.get_child_possessables()
        
        # Recursively remove all children first
        for child in child_possessables:
            print(f"Removing child binding: {str(child.get_display_name())}")
            remove_binding_and_children_recursive(child)
        
        # Finally remove the parent binding
        binding_name = str(binding.get_display_name())
        print(f"Removing parent binding: {binding_name}")
        binding.remove()
        
    except Exception as e:
        print(f"Error removing binding: {e}")

def import_camera_fbx_to_sequence(world, level_sequence, fbx_file_path, camera_name, replace_existing=True, asset_path=None, camera_file=None, source_key=None):
    """
    Import FBX camera directly into a level sequence using the official Unreal Engine API.
    This creates the camera actors and imports animation in one step, setting them as spawnable.
    Includes version checking and metadata management.
    
    Args:
        world: The Unreal world context
        level_sequence: The level sequence to import into
        fbx_file_path (str): Path to the FBX file to import
        camera_name (str): Name of the camera to make spawnable
        replace_existing (bool): If True, removes existing camera with same name. 
                                If False, updates existing camera animation.
        asset_path (str): Optional path to the asset folder for the imported camera.
        camera_file (dict): Camera file data from pipeline API for metadata
        source_key (str): Original database key for the camera file

Returns:
        bool: True if import was successful, False otherwise

TODO: Implement asset path handling to create the camera asset.
    """
    if not UNREAL_AVAILABLE or not level_sequence or not world:
        return False
    
    try:
        # Get level sequence path for metadata operations
        level_sequence_path = level_sequence.get_path_name()
        
        # Check if camera needs to be reimported (if metadata is available)
        if camera_file and source_key:
            if not should_reimport_camera(level_sequence_path, camera_file, camera_name):
                print(f"Camera '{camera_name}' already up to date in level sequence, skipping import")
                return True
        
        # Check if camera already exists
        existing_binding = find_existing_binding(level_sequence, camera_name)
        
        if existing_binding:
            if replace_existing:
                # Option 1: Remove existing and import fresh
                print(f"Camera '{camera_name}' already exists. Removing and reimporting...")
                remove_binding_and_children_recursive(existing_binding)
        
        # Set up FBX import options for cameras
        import_options = unreal.MovieSceneUserImportFBXSettings()
        import_options.set_editor_property('create_cameras', True)
        import_options.set_editor_property('reduce_keys', False)
        import_options.set_editor_property('match_by_name_only', True)
        
        # Get existing bindings before import
        bindings_before = level_sequence.get_bindings()
        
        # Import FBX using the official Sequencer Tools API
        success = unreal.SequencerTools.import_level_sequence_fbx(
            world, 
            level_sequence, 
            bindings_before,
            import_options, 
            fbx_file_path
        )
        
        if success:
            print(f"Successfully imported FBX camera: {fbx_file_path}")
            ls_system = unreal.get_editor_subsystem(unreal.LevelSequenceEditorSubsystem)
            
            # Get all bindings after import to find the camera
            bindings_after = level_sequence.get_bindings()
            
            # Find the camera binding (either new or existing)
            camera_binding = find_existing_binding(level_sequence, camera_name)
            
            if camera_binding:
                binding_name = str(camera_binding.get_display_name())
                print(f"Found camera binding: {binding_name}")
                
                # Open sequence and convert to spawnable
                unreal.LevelSequenceEditorBlueprintLibrary.open_level_sequence(level_sequence)
                ls_system.convert_to_spawnable(camera_binding)
                
                print(f"Camera '{binding_name}' set as spawnable")
            else:
                # Fallback: look for new bindings if camera_name matching failed
                new_bindings = [binding for binding in bindings_after if binding not in bindings_before]
                
                for binding in new_bindings:
                    binding_name = str(binding.get_display_name())
                    print(f"Found new binding: {binding_name}")
                    
                    # Open sequence and convert to spawnable
                    unreal.LevelSequenceEditorBlueprintLibrary.open_level_sequence(level_sequence)
                    ls_system.convert_to_spawnable(binding)
                    
                    print(f"Camera '{binding_name}' set as spawnable")
                    break
            
            # Add camera metadata to level sequence if camera data is available
            if camera_file and source_key and level_sequence_path:
                add_camera_metadata(level_sequence_path, camera_file, source_key, camera_name)
            
            return True
        else:
            print(f"Failed to import FBX camera: {fbx_file_path}")
            return False
            
    except Exception as e:
        print(f"Error importing FBX camera: {e}")
        return False

# End load cameras code

# Load Anim cache code

def load_task_caches(task_key, level_sequence, project_folder):
    """
    Load cache abc files into Unreal project, assign materials and add them to the level sequence.

This function must:
    - Import each alembic cache file in the project_folder given.
    - Add them to the level sequence.
    - Assign the materials to the alembic based on the materials names assigned to the face sets. The alembic
      is from Maya. Each material slot will have a name of the type {namespace}:{materialName}. The function
      will search for the material with the name {materialName} in the project and recover the assign in the cache.
    
    Args:
        task_key (str): The task key to get cache files from
        level_sequence: The Unreal level sequence to add cache to
        project_folder (str): The project folder path where cache should be imported
                              (e.g., "Episodes/ep101/sq001/shots/sh0010/cache/")
    
    Returns:
        list: List of imported cache bindings
    """
    if not UNREAL_AVAILABLE:
        print("Cannot load caches: Unreal Engine API not available")
        return []
    
    folder = get_task_last_folder(task_key, "cache")
    if not folder:
        print(f"No cache folder found for task: {task_key}")
        return []

# Get cache files
    cache_files = []
    for file in folder.get('files', []):
        if file.get('fileName', '').lower().endswith('.abc'):
            cache_files.append(file)

if not cache_files:
        print(f"No ABC cache files found for task: {task_key}")
        return []

imported_cache_bindings = []
    
    # Get the world context
    world = unreal.EditorLevelLibrary.get_editor_world()
    if not world:
        print("Could not get editor world")
        return []
    
    # Process each cache file
    for cache_file in cache_files:
        file_path = cache_file.get('pathToFile')
        file_name = cache_file.get('fileName')
        # Get cache data for import
        cache_data = cache_file.get("data")
        cache_start = None
        cache_end = None
        cache_name = os.path.splitext(file_name)[0]
        print(f"Cache file data: {cache_data}")
        if cache_data:
            try:
                cache_data = ast.literal_eval(cache_data).get("cache", {})
                cache_range = cache_data.get("frame_range")
                if cache_range:
                    cache_start = cache_range[0]
                    cache_end = cache_range[1]
                # Asset Name
                cache_name = cache_data.get("namespace", cache_name)
            except (ValueError, SyntaxError) as e:
                print(f"Error parsing cache data for cache data from {file_name}: {e}")

if not file_path or not os.path.exists(file_path):
            print(f"Cache file not found: {file_path}")
            continue
        
        
        
        try:
            # Check if we need to reimport the cache by comparing versions
            expected_asset_path = f"{project_folder}/{cache_name}"
            should_import = should_reimport_cache(expected_asset_path, cache_file)
            
            imported_asset = None
            asset_path = None
            
            if should_import:
                # Import Alembic cache to project with metadata
                imported_asset, asset_path = import_alembic_cache(
                    file_path, project_folder, cache_name, 
                    start_frame=cache_start, end_frame=cache_end,
                    cache_file=cache_file, source_key=cache_file.get("key"))
                
                if not imported_asset:
                    print(f"Failed to import cache: {cache_name}")
                    continue
            else:
                # Load existing asset since we're not reimporting
                asset_path = expected_asset_path
                imported_asset = unreal.EditorAssetLibrary.load_asset(asset_path) if UNREAL_AVAILABLE else None
                if not imported_asset:
                    print(f"Failed to load existing cache: {cache_name}, will try to reimport")
                    # Fallback: try to import anyway
                    imported_asset, asset_path = import_alembic_cache(
                        file_path, project_folder, cache_name, 
                        start_frame=cache_start, end_frame=cache_end,
                        cache_file=cache_file, source_key=cache_file.get("key"))
            
            if not imported_asset:
                print(f"Failed to get cache asset: {cache_name}")
                continue
            
            # Create spawnable from imported asset instead of level actor
            spawnable_binding = create_spawnable_from_asset(level_sequence, imported_asset, cache_name)
            if spawnable_binding:
                imported_cache_bindings.append(spawnable_binding)
                print(f"Successfully added cache as spawnable to sequence: {cache_name}")
            else:
                print(f"Failed to add cache as spawnable to sequence: {cache_name}")
                
        except Exception as e:
            print(f"Error processing cache {file_name}: {e}")
    
    return imported_cache_bindings

def import_alembic_cache(file_path, destination_path, asset_name, start_frame=None, end_frame=None, cache_file=None, source_key=None):
    """
    Import an Alembic cache file into the Unreal project.
    
    Args:
        file_path (str): Path to the .abc file
        destination_path (str): Unreal project path where to import
        asset_name (str): Name for the imported asset
        start_frame (int): Optional start frame for cache
        end_frame (int): Optional end frame for cache
        cache_file (dict): Optional cache file data for metadata
        source_key (str): Optional source key for metadata
        
    Returns:
        tuple: (imported_asset, asset_path) or (None, None) if failed
    """
    if not UNREAL_AVAILABLE:
        return None, None
    
    try:
        # Create import task
        import_task = unreal.AssetImportTask()
        import_task.set_editor_property('automated', True)
        import_task.set_editor_property('destination_path', destination_path)
        import_task.set_editor_property('destination_name', asset_name)
        import_task.set_editor_property('filename', file_path)
        import_task.set_editor_property('replace_existing', True)
        import_task.set_editor_property('save', True)
        
        # Sampling
        sampling_settings = unreal.AbcSamplingSettings()
        if start_frame is not None:
            sampling_settings.set_editor_property('frame_start', start_frame)
        if end_frame is not None:
            sampling_settings.set_editor_property('frame_end', end_frame)
        sampling_settings.set_editor_property('frame_steps', 1)

# Set material settings to create materials from face sets
        material_settings = unreal.AbcMaterialSettings()
        material_settings.set_editor_property('create_materials', True)
        material_settings.set_editor_property('find_materials', True)

# Configure Alembic import settings
        import_options = unreal.AbcImportSettings()
        import_options.set_editor_property('import_type', unreal.AlembicImportType.GEOMETRY_CACHE)
        import_options.set_editor_property('material_settings', material_settings)
        import_options.set_editor_property('sampling_settings', unreal.AbcSamplingSettings())
        import_options.set_editor_property('normal_generation_settings', unreal.AbcNormalGenerationSettings())
        import_options.set_editor_property('sampling_settings', sampling_settings)
        
        import_task.set_editor_property('options', import_options)
        
        # Import the asset
        print(f"Importing Alembic cache with range {start_frame} - {end_frame}")
        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
        imported_assets = asset_tools.import_asset_tasks([import_task])
        
        if import_task.imported_object_paths and len(import_task.imported_object_paths) > 0:
            # Get the first imported object path
            imported_path = import_task.imported_object_paths[0]
            imported_asset = unreal.EditorAssetLibrary.load_asset(imported_path)
            
            if imported_asset:
                print(f"Successfully imported Alembic cache: {asset_name}")
                
                # Add metadata if cache_file and source_key are provided
                if cache_file and source_key:
                    add_cache_metadata(imported_path, cache_file, source_key)
                
                return imported_asset, imported_path
            else:
                print(f"Failed to load imported Alembic cache: {asset_name}")
                return None, None
        else:
            print(f"No objects imported for Alembic cache: {asset_name}")
            return None, None
            
    except Exception as e:
        print(f"Error importing Alembic cache: {e}")
        return None, None

def create_spawnable_from_asset(level_sequence, asset, spawnable_name, replace_existing=False):
    """
    Create a spawnable object in the level sequence from an imported asset.
    
    Args:
        level_sequence: The level sequence to add the spawnable to
        asset: The imported asset (GeometryCache, StaticMesh, SkeletalMesh)
        spawnable_name (str): Name for the spawnable
        replace_existing (bool): Whether to replace an existing spawnable with the same name

Returns:
        Spawnable binding or None if failed
    """
    if not UNREAL_AVAILABLE or not level_sequence or not asset:
        return None
    
    try:
        # Determine the appropriate actor class based on asset type
        if isinstance(asset, unreal.SkeletalMesh):
            actor_class = unreal.SkeletalMeshActor
        elif isinstance(asset, unreal.StaticMesh):
            actor_class = unreal.StaticMeshActor
        elif isinstance(asset, unreal.GeometryCache):
            actor_class = unreal.GeometryCacheActor
        else:
            print(f"Unsupported asset type for spawnable creation: {type(asset)}")
            return None
        # Check if binding already exists
        existing_binding = find_existing_binding(level_sequence, spawnable_name)

if existing_binding and not replace_existing:
            print(f"Spawnable with name '{spawnable_name}' already exists.")
            return existing_binding

# Create spawnable from the actor class
        spawnable_binding = level_sequence.add_spawnable_from_class(actor_class)
        
        if spawnable_binding:
            # Set the spawnable name
            spawnable_binding.set_name(spawnable_name)
            spawnable_binding.set_display_name(spawnable_name)
            print(f"Creating spawnable: {spawnable_name} with name: {spawnable_binding.get_display_name()}")

# Get the spawnable's object template to configure it
            spawnable_template = spawnable_binding.get_object_template()
            
            if spawnable_template:
                # Configure the spawnable template with the imported asset
                if isinstance(asset, unreal.SkeletalMesh):
                    skeletal_mesh_component = spawnable_template.get_skeletal_mesh_component()
                    if skeletal_mesh_component:
                        skeletal_mesh_component.set_skeletal_mesh(asset)
                elif isinstance(asset, unreal.StaticMesh):
                    static_mesh_component = spawnable_template.get_static_mesh_component()
                    if static_mesh_component:
                        static_mesh_component.set_static_mesh(asset)
                elif isinstance(asset, unreal.GeometryCache):
                    geometry_cache_component = spawnable_template.get_geometry_cache_component()
                    if geometry_cache_component:
                        geometry_cache_component.set_geometry_cache(asset)
                
                # Add appropriate tracks based on asset type
                if isinstance(asset, unreal.GeometryCache):
                    # Add geometry cache track for animated cache
                    geometry_cache_track = spawnable_binding.add_track(unreal.MovieSceneGeometryCacheTrack)
                    if geometry_cache_track:
                        print(f"Added spawnable with geometry cache track: {spawnable_name}")
                    else:
                        print(f"Failed to add geometry cache track for spawnable: {spawnable_name}")
                else:
                    # Add transform track for other asset types
                    transform_track = spawnable_binding.add_track(unreal.MovieScene3DTransformTrack)
                    if transform_track:
                        print(f"Added spawnable with transform track: {spawnable_name}")
                    else:
                        print(f"Added spawnable without transform track: {spawnable_name}")
                
                print(f"Successfully created spawnable: {spawnable_name}")
                return spawnable_binding
            else:
                print(f"Failed to get object template for spawnable: {spawnable_name}")
                return None
        else:
            print(f"Failed to create spawnable: {spawnable_name}")
            return None
            
    except Exception as e:
        print(f"Error creating spawnable from asset: {e}")
        return None

def create_actor_from_asset(world, asset, actor_name):
    """
    Create an actor in the level from an imported asset.
    
    Args:
        world: The Unreal world context
        asset: The imported asset
        actor_name (str): Name for the actor
        
    Returns:
        Created actor or None if failed
    """
    if not UNREAL_AVAILABLE or not world or not asset:
        return None
    
    try:
        # Determine actor class based on asset type
        if isinstance(asset, unreal.SkeletalMesh):
            actor_class = unreal.SkeletalMeshActor
        elif isinstance(asset, unreal.StaticMesh):
            actor_class = unreal.StaticMeshActor
        elif isinstance(asset, unreal.GeometryCache):
            actor_class = unreal.GeometryCacheActor
        else:
            print(f"Unsupported asset type for actor creation: {type(asset)}")
            return None
        
        # Spawn actor from asset
        actor_location = unreal.Vector(0.0, 0.0, 0.0)
        actor_rotation = unreal.Rotator(0.0, 0.0, 0.0)
        
        actor = unreal.EditorLevelLibrary.spawn_actor_from_object(
            asset, 
            actor_location, 
            actor_rotation
        )
        
        if actor:
            # Set actor name
            actor.set_actor_label(actor_name)
            print(f"Created actor: {actor_name}")
            return actor
        else:
            print(f"Failed to create actor: {actor_name}")
            return None
            
    except Exception as e:
        print(f"Error creating actor from asset: {e}")
        return None

def add_actor_to_sequence(level_sequence, actor):
    """
    Add an actor to a level sequence as a possessable.
    
    Args:
        level_sequence: The level sequence to add the actor to
        actor: The actor to add
        
    Returns:
        Binding object or None if failed
    """
    if not UNREAL_AVAILABLE or not level_sequence or not actor:
        return None
    
    try:
        # Add actor as possessable to the sequence
        binding = level_sequence.add_possessable(actor)
        
        if binding:
            # Add appropriate tracks based on actor type
            if isinstance(actor, unreal.GeometryCacheActor):
                # Add geometry cache track for animated cache
                geometry_cache_track = binding.add_track(unreal.MovieSceneGeometryCacheTrack)
                if geometry_cache_track:
                    print(f"Added actor to sequence with geometry cache track: {actor.get_actor_label()}")
                else:
                    print(f"Failed to add geometry cache track for: {actor.get_actor_label()}")
            else:
                # Add transform track for other actor types
                transform_track = binding.add_track(unreal.MovieScene3DTransformTrack)
                if transform_track:
                    print(f"Added actor to sequence with transform track: {actor.get_actor_label()}")
                else:
                    print(f"Added actor to sequence without transform track: {actor.get_actor_label()}")
            
            return binding
        else:
            print(f"Failed to add actor to sequence: {actor.get_actor_label()}")
            return None
            
    except Exception as e:
        print(f"Error adding actor to sequence: {e}")
        return None

# Cache metadata and version management functions

def get_cache_versions(cache_file):
    """
    Extract review and wip versions from cache file data with fallback logic.
    
    Args:
        cache_file (dict): Cache file data containing folder information
        
    Returns:
        tuple: (review_version, wip_version) - can contain None values if not available
    """
    folder_info = cache_file.get("folder", {})
    
    # Try to get versions from main folder
    review_version = folder_info.get("review")
    wip_version = folder_info.get("wip")
    
    # If not available, try dependence folder as fallback
    if review_version is None or wip_version is None:
        dependence_info = folder_info.get("dependence", {})
        if review_version is None:
            review_version = dependence_info.get("review")
        if wip_version is None:
            wip_version = dependence_info.get("wip")
    
    return review_version, wip_version

def get_camera_versions(camera_file):
    """
    Extract review and wip versions from camera file data with fallback logic.
    
    Args:
        camera_file (dict): Camera file data containing folder information
        
    Returns:
        tuple: (review_version, wip_version) - can contain None values if not available
    """
    folder_info = camera_file.get("folder", {})
    
    # Try to get versions from main folder
    review_version = folder_info.get("review")
    wip_version = folder_info.get("wip")
    
    # If not available, try dependence folder as fallback
    if review_version is None or wip_version is None:
        dependence_info = folder_info.get("dependence", {})
        if review_version is None:
            review_version = dependence_info.get("review")
        if wip_version is None:
            wip_version = dependence_info.get("wip")
    
    return review_version, wip_version

def add_cache_metadata(asset_path, cache_file, source_key):
    """
    Adds pipeline metadata to an imported cache asset using EditorAssetLibrary.
    Based on add_asset_metadata from assets.py but adapted for cache files.
    
    Args:
        asset_path (str): The path to the imported cache asset in Unreal
        cache_file (dict): The cache file information from the pipeline API
        source_key (str): The original database key for the cache file
        
    Returns:
        bool: True if metadata was successfully added, False otherwise
    """
    if not UNREAL_AVAILABLE:
        return False
        
    try:
        # Load the asset first (required for metadata operations)
        loaded_asset = unreal.EditorAssetLibrary.load_asset(asset_path)
        if not loaded_asset:
            print(f"Could not load cache asset for metadata: {asset_path}")
            return False
        
        # Prepare metadata
        metadata_tags = {}
        
        # Add source key
        if source_key:
            metadata_tags["pipelinepro_file_key"] = source_key
        
        # Add file name
        file_name = cache_file.get("fileName", "")
        if file_name:
            metadata_tags["pipelinepro_file_name"] = file_name
        
        # Add original file path
        original_path = cache_file.get("pathToFile") or cache_file.get("fileLocal")
        if original_path:
            metadata_tags["pipelinepro_file_path"] = original_path
        
        # Add import date
        import datetime
        import_date = datetime.datetime.now().isoformat()
        metadata_tags["pipelinepro_import_date"] = import_date
        
        # Add review and wip versions using helper function
        review_version, wip_version = get_cache_versions(cache_file)
        metadata_tags["pipelinepro_review"] = str(review_version) if review_version is not None else "None"
        metadata_tags["pipelinepro_wip"] = str(wip_version) if wip_version is not None else "None"
        
        # Set metadata tags using EditorAssetLibrary
        for key, value in metadata_tags.items():
            unreal.EditorAssetLibrary.set_metadata_tag(loaded_asset, key, str(value))
        
        # Save the asset to persist metadata changes
        unreal.EditorAssetLibrary.save_asset(asset_path)
        
        print(f"Added pipeline metadata to cache asset: {asset_path}")
        return True
        
    except Exception as e:
        print(f"Error adding metadata to cache asset '{asset_path}': {e}")
        return False

def add_camera_metadata(level_sequence_path, camera_file, source_key, camera_name):
    """
    Adds pipeline metadata to a level sequence for an imported camera using EditorAssetLibrary.
    Based on add_cache_metadata but adapted for cameras in level sequences.
    
    Args:
        level_sequence_path (str): The path to the level sequence asset in Unreal
        camera_file (dict): The camera file information from the pipeline API
        source_key (str): The original database key for the camera file
        camera_name (str): The name of the imported camera
        
    Returns:
        bool: True if metadata was successfully added, False otherwise
    """
    if not UNREAL_AVAILABLE:
        return False
        
    try:
        # Load the level sequence asset first (required for metadata operations)
        loaded_asset = unreal.EditorAssetLibrary.load_asset(level_sequence_path)
        if not loaded_asset:
            print(f"Could not load level sequence for camera metadata: {level_sequence_path}")
            return False
        
        # Prepare metadata with camera_ prefix
        metadata_tags = {}
        
        # Add source key
        if source_key:
            metadata_tags["camera_pipelinepro_file_key"] = source_key
        
        # Add camera name
        if camera_name:
            metadata_tags["camera_pipelinepro_camera_name"] = camera_name
        
        # Add file name
        file_name = camera_file.get("fileName", "")
        if file_name:
            metadata_tags["camera_pipelinepro_file_name"] = file_name
        
        # Add original file path
        original_path = camera_file.get("pathToFile") or camera_file.get("fileLocal")
        if original_path:
            metadata_tags["camera_pipelinepro_file_path"] = original_path
        
        # Add import date
        import datetime
        import_date = datetime.datetime.now().isoformat()
        metadata_tags["camera_pipelinepro_import_date"] = import_date
        
        # Add review and wip versions using helper function
        review_version, wip_version = get_camera_versions(camera_file)
        metadata_tags["camera_pipelinepro_review"] = str(review_version) if review_version is not None else "None"
        metadata_tags["camera_pipelinepro_wip"] = str(wip_version) if wip_version is not None else "None"
        
        # Set metadata tags using EditorAssetLibrary
        for key, value in metadata_tags.items():
            unreal.EditorAssetLibrary.set_metadata_tag(loaded_asset, key, str(value))
        
        # Save the asset to persist metadata changes
        unreal.EditorAssetLibrary.save_asset(level_sequence_path)
        
        print(f"Added camera metadata to level sequence: {level_sequence_path} (camera: {camera_name})")
        return True
        
    except Exception as e:
        print(f"Error adding camera metadata to level sequence '{level_sequence_path}': {e}")
        return False

def should_reimport_cache(asset_path, cache_file):
    """
    Check if a cache should be reimported by comparing versions with existing metadata.
    
    Args:
        asset_path (str): The path to the existing cache asset in Unreal
        cache_file (dict): The current cache file information
        
    Returns:
        bool: True if cache should be reimported, False if versions are the same
    """
    if not UNREAL_AVAILABLE:
        return True  # Default to reimport if Unreal not available
        
    try:
        # Check if asset exists
        if not unreal.EditorAssetLibrary.does_asset_exist(asset_path):
            return True  # Import if asset doesn't exist
        
        # Load the asset to get metadata
        loaded_asset = unreal.EditorAssetLibrary.load_asset(asset_path)
        if not loaded_asset:
            print(f"Could not load existing cache asset: {asset_path}")
            return True  # Default to reimport if can't load
        
        # Get stored versions from metadata
        stored_review = unreal.EditorAssetLibrary.get_metadata_tag(loaded_asset, "pipelinepro_review")
        stored_wip = unreal.EditorAssetLibrary.get_metadata_tag(loaded_asset, "pipelinepro_wip")
        
        # If no metadata exists, reimport
        if not stored_review and not stored_wip:
            print(f"No version metadata found for {asset_path}, reimporting...")
            return True
        
        # Get current versions from cache file
        current_review, current_wip = get_cache_versions(cache_file)
        current_review_str = str(current_review) if current_review is not None else "None"
        current_wip_str = str(current_wip) if current_wip is not None else "None"
        
        # Compare versions
        review_changed = stored_review != current_review_str
        wip_changed = stored_wip != current_wip_str
        
        if review_changed or wip_changed:
            print(f"Version changed for {asset_path}: review({stored_review}->{current_review_str}) wip({stored_wip}->{current_wip_str})")
            return True
        else:
            print(f"Cache {asset_path} already imported with same versions (review:{current_review_str}, wip:{current_wip_str})")
            return False
            
    except Exception as e:
        print(f"Error checking cache versions for '{asset_path}': {e}")
        return True  # Default to reimport on error

def should_reimport_camera(level_sequence_path, camera_file, camera_name):
    """
    Check if a camera should be reimported by comparing versions with existing metadata in level sequence.
    
    Args:
        level_sequence_path (str): The path to the level sequence asset in Unreal
        camera_file (dict): The current camera file information
        camera_name (str): The name of the camera to check
        
    Returns:
        bool: True if camera should be reimported, False if versions are the same
    """
    if not UNREAL_AVAILABLE:
        return True  # Default to reimport if Unreal not available
        
    try:
        # Check if level sequence exists
        if not unreal.EditorAssetLibrary.does_asset_exist(level_sequence_path):
            return True  # Import if level sequence doesn't exist
        
        # Load the level sequence to get metadata
        loaded_asset = unreal.EditorAssetLibrary.load_asset(level_sequence_path)
        if not loaded_asset:
            print(f"Could not load existing level sequence: {level_sequence_path}")
            return True  # Default to reimport if can't load
        
        # Get stored versions from metadata (with camera_ prefix)
        stored_review = unreal.EditorAssetLibrary.get_metadata_tag(loaded_asset, "camera_pipelinepro_review")
        stored_wip = unreal.EditorAssetLibrary.get_metadata_tag(loaded_asset, "camera_pipelinepro_wip")
        stored_camera_name = unreal.EditorAssetLibrary.get_metadata_tag(loaded_asset, "camera_pipelinepro_camera_name")
        
        # If no metadata exists, reimport
        if not stored_review and not stored_wip:
            print(f"No camera version metadata found for {level_sequence_path}, reimporting...")
            return True
        
        # If camera name changed, reimport
        if stored_camera_name and stored_camera_name != camera_name:
            print(f"Camera name changed for {level_sequence_path}: {stored_camera_name} -> {camera_name}")
            return True
        
        # Get current versions from camera file
        current_review, current_wip = get_camera_versions(camera_file)
        current_review_str = str(current_review) if current_review is not None else "None"
        current_wip_str = str(current_wip) if current_wip is not None else "None"
        
        # Compare versions
        review_changed = stored_review != current_review_str
        wip_changed = stored_wip != current_wip_str
        
        if review_changed or wip_changed:
            print(f"Camera version changed for {level_sequence_path}: review({stored_review}->{current_review_str}) wip({stored_wip}->{current_wip_str})")
            return True
        else:
            print(f"Camera {camera_name} already imported with same versions (review:{current_review_str}, wip:{current_wip_str})")
            return False
            
    except Exception as e:
        print(f"Error checking camera versions for '{level_sequence_path}': {e}")
        return True  # Default to reimport on error

# End Cache metadata and version management functions

# End Load Anim cache code

# Render Job Queue Template functions

def get_light_shot_task_output_path(shot_task):
    """
    Find the Light Shot task from shot tasks and return the output path.
    
    Args:
        shot_tasks (list): List of tasks for a shot
        
    Returns:
        str: Output path (folderLocal + /render) or None if not found
    """
    maintask = shot_task.get('maintask', {})
    if maintask.get('tecnicalName') == 'light':
        folder_local = shot_task.get('folderLocal')
        if folder_local:
            return os.path.join(folder_local, 'render').replace('\\', '/')
    return None

def save_pipeline_preset(config, preset_name, asset_path="/Game/MoviePipeline/Presets/"):
    """
    Save the current pipeline configuration as a preset
    
    Args:
        config: The MoviePipelineExecutorJob configuration
        preset_name: Name for the preset
        asset_path: Asset path where to save the preset
    """
    try:
        full_package_path = asset_path.rstrip('/')
        
        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
        
        preset_asset = asset_tools.create_asset(
            asset_name=preset_name,
            package_path=full_package_path,
            asset_class=unreal.MoviePipelinePrimaryConfig,
            factory=unreal.MoviePipelinePrimaryConfigFactory()
        )
        
        if preset_asset:
            # Copy each setting individually from the job config
            for setting in config.get_all_settings():
                if setting:
                    # Create a copy of the setting for the preset
                    setting_class = setting.get_class()
                    new_setting = preset_asset.find_or_add_setting_by_class(setting_class)
                    if new_setting:
                        # Copy properties from the original setting
                        for prop in setting_class.get_properties():
                            try:
                                value = setting.get_editor_property(prop.get_name())
                                new_setting.set_editor_property(prop.get_name(), value)
                            except:
                                pass
            
            # Mark the asset as dirty to ensure it saves properly
            unreal.EditorAssetLibrary.mark_package_dirty_for_asset(preset_asset)
            
            asset_path_full = f"{full_package_path}/{preset_name}"
            success = unreal.EditorAssetLibrary.save_asset(asset_path_full)
            
            if success:
                print(f"Successfully saved preset: {asset_path_full}")
                return preset_asset
            else:
                print(f"Failed to save preset asset: {asset_path_full}")
                return None
        else:
            print("Failed to create preset asset")
            return None
            
    except Exception as e:
        print(f"Error saving preset: {e}")
        return None

def create_render_job_template(shot_technical_name, level_sequence, output_path, shot_start, shot_end, shot_start_offset, shot_path):
    """
    Create a render job queue template for a shot.
    
    Args:
        shot_technical_name (str): Technical name of the shot
        level_sequence: The level sequence to render
        output_path (str): Output path for rendered frames
        shot_start (int): Start frame of the shot in sequence timeline
        shot_end (int): End frame of the shot in sequence timeline
        
    Returns:
        bool: True if successful, False otherwise
    """
    if not UNREAL_AVAILABLE:
        print("Cannot create render job template: Unreal Engine API not available")
        return False
    
    try:
        # Get Movie Render Pipeline subsystem
        subsystem = unreal.get_editor_subsystem(unreal.MoviePipelineQueueSubsystem)
        if not subsystem:
            print("Could not get Movie Pipeline Queue Subsystem")
            return False
            
        # Get or create queue
        queue = subsystem.get_queue()
        if not queue:
            print("Could not get render queue")
            return False
            
        # Create new job - Use correct class name
        job = queue.allocate_new_job(unreal.MoviePipelineExecutorJob)
        if not job:
            print(f"Failed to create render job for shot: {shot_technical_name}")
            return False
            
        # Set job name
        job.job_name = f"Render_{shot_technical_name}"
        
        # Set sequence reference
        job.sequence = unreal.SoftObjectPath(level_sequence.get_path_name())
        
        preset_name = f"{shot_technical_name}_RenderJob"
        preset_path = f"{shot_path}/{preset_name}"
        full_preset_path = f"{preset_path}.{preset_name}"
        
        # Check if preset already exists
        preset_shot = None
        preset_existed = unreal.EditorAssetLibrary.does_asset_exist(full_preset_path)
        
        if preset_existed:
            # Load existing preset to preserve user modifications
            preset_shot = unreal.EditorAssetLibrary.load_asset(full_preset_path)
            if preset_shot:
                print(f"Found existing render preset: {preset_name}, updating frame range and output settings")
            else:
                print(f"Failed to load existing preset: {preset_name}")
        
        if not preset_shot:
            # Create new preset only if it doesn't exist or failed to load
            asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
            preset_shot = asset_tools.create_asset(
                asset_name=preset_name,
                package_path=shot_path,
                asset_class=unreal.MoviePipelinePrimaryConfig,
                factory=unreal.MoviePipelinePrimaryConfigFactory()
            )
            if preset_shot:
                print(f"Created new render preset: {preset_name}")
        
        if not preset_shot:
            print(f"Failed to create or load render preset: {preset_name}")
            return False

# Configure output settings - always update these for both new and existing presets
        output_setting = preset_shot.find_or_add_setting_by_class(unreal.MoviePipelineOutputSetting)
        if output_setting:
            # Use set_editor_property with correct property names for Movie Pipeline
            try:
                # The output directory property for Movie Pipeline outputs
                output_setting.set_editor_property('output_directory', unreal.DirectoryPath(output_path))
                print(f"Set output directory to: {output_path}")
            except Exception as e:
                print(f"Failed to set output directory: {e}")
            
            try:
                # Set file name format
                output_setting.set_editor_property('file_name_format', shot_technical_name + ".{frame_number}")
                print(f"Set file name format to: {shot_technical_name}.{{frame_number}}")
            except Exception as e:
                print(f"Failed to set file name format: {e}")
        
            # Use set_editor_property for camera settings
            try:
                output_setting.set_editor_property('use_custom_playback_range', True)
                output_setting.set_editor_property('custom_start_frame', shot_start)
                output_setting.set_editor_property('custom_end_frame', shot_end)
                output_setting.set_editor_property('frame_number_offset', shot_start_offset)
                print(f"Set frame range: {shot_start}-{shot_end}")
            except Exception as e:
                print(f"Failed to set frame range: {e}")

# Only add default settings for new presets to preserve user customizations
        if not preset_existed:
            # Add deferred rendering configuration
            deferred_rendering_setting = preset_shot.find_or_add_setting_by_class(unreal.MoviePipelineDeferredPassBase)
            if deferred_rendering_setting:
                try:
                    # Enable deferred rendering
                    deferred_rendering_setting.set_editor_property('disable_multisample_effects', False)
                    print("Configured deferred rendering settings")
                except Exception as e:
                    print(f"Failed to configure deferred rendering: {e}")

# Add PNG image sequence output
            png_output = preset_shot.find_or_add_setting_by_class(unreal.MoviePipelineImageSequenceOutput_PNG)

# Add anti-aliasing settings (optional but recommended for quality)
            aa_setting = preset_shot.find_or_add_setting_by_class(unreal.MoviePipelineAntiAliasingSetting)

job.set_configuration(preset_shot)
        print(f"Created render job template: {job.job_name} -> {output_path} (frames {shot_start}-{shot_end})")
        return True
        
    except Exception as e:
        print(f"Error creating render job template for {shot_technical_name}: {e}")
        return False

# End Render Job Queue Template functions

def fps_string_to_fraction(fps_str):
    """
    Convert frame rate string to (numerator, denominator) tuple for Unreal Engine.
    
    Args:
        fps_str (str): Frame rate as string (e.g., "29.97", "30", "25")
        
    Returns:
        tuple: (numerator, denominator) for use with unreal.FrameRate()
        
    Examples:
        fps_string_to_fraction("30") -> (30, 1)
        fps_string_to_fraction("29.97") -> (30000, 1001)
        fps_string_to_fraction("23.976") -> (24000, 1001)
        fps_string_to_fraction("59.94") -> (60000, 1001)
    """
    try:
        fps_float = float(fps_str)
        
        # Handle common NTSC frame rates that need specific fractions
        if abs(fps_float - 29.97) < 0.01:
            return unreal.FrameRate(numerator=30000, denominator=1001)
        elif abs(fps_float - 23.976) < 0.01 or abs(fps_float - 23.98) < 0.01:
            return unreal.FrameRate(numerator=24000, denominator=1001)
        elif abs(fps_float - 59.94) < 0.01:
            return unreal.FrameRate(numerator=60000, denominator=1001)
        elif abs(fps_float - 47.952) < 0.01:
            return unreal.FrameRate(numerator=48000, denominator=1001)
        # Handle integer frame rates
        elif fps_float == int(fps_float):
            return unreal.FrameRate(numerator=int(fps_float), denominator=1)
        else:
            # For other decimal frame rates, use a simple fraction
            from fractions import Fraction
            frac = Fraction(fps_float).limit_denominator(10000)
            return unreal.FrameRate(numerator=frac.numerator, denominator=frac.denominator)

except (ValueError, TypeError):
        # Default to 24fps if conversion fails
        print(f"Warning: Could not parse frame rate '{fps_str}', defaulting to 24fps")
        return unreal.FrameRate(numerator=24, denominator=1)

def get_project_data(episode_key):
    query = """
    query{
        myProject(token: "{token}"){
            fps: data(field:"project_fps") 
        }
        episode(episodeKey:"{episode_key}", token: "{token}"){
            code
            fullcode
            sequences{
            name
            number
            tecnicalName
            shots{
                name
                tecnicalName
                inFrame
                outFrame
                startFrame
                code
                endFrame
                tasks{
                    folderLocal
                    code
                    name
                    key
                    maintask{
                        name
                        tecnicalName
                    }
                }
            }
            }
        }
    }
    """
    query = query.replace("{episode_key}", episode_key)

response = pipeline.query(query)
    if not response or 'errors' in response:
        return {}
    project_data = response.get('myProject', {})
    project_data['episodes'] = [response.get('episode', {})]
    return project_data

def get_project_episode(project):
    # project example: VFX_104_lighting.uproject
    query = """
    query{
      file(fileName:"{filename}", token:"{token}"){
        task{
          relEpisodeTask{
            code
            key
          }
        }
      }
    }
    """
    query = query.replace("{filename}", project)
    response = pipeline.query(query)
    if not response or 'errors' in response:
        return None
    episodes = response.get('file', {}).get('task', {}).get('relEpisodeTask', [])
    if not episodes:
        return None
    return episodes[0]

def create_sequence_directory_structure(episodes):
    """
    Create physical folder structure: Sequences/{sequenceName}/shots/{shotTechnicalName}
    """
    if not UNREAL_AVAILABLE:
        print("Cannot create directories: Unreal Engine API not available")
        return
    
    base_path = "/Game/Episodes"

# Ensure base Episodes folder exists
    if not unreal.EditorAssetLibrary.does_directory_exist(base_path):
        success = unreal.EditorAssetLibrary.make_directory(base_path)
        if success:
            print(f"Created base directory: {base_path}")
        else:
            print(f"Failed to create base directory: {base_path}")
            return
    
    for episode in episodes:
        episode_code = episode.get('code')
        sequences = episode.get('sequences', [])
        # Create sequence directory
        episode_path = f"{base_path}/ep{episode_code}"
        if not unreal.EditorAssetLibrary.does_directory_exist(episode_path):
            success = unreal.EditorAssetLibrary.make_directory(episode_path)
            if success:
                print(f"Created episode directory: {episode_path}")
            else:
                print(f"Failed to create episode directory: {episode_path}")
                continue
        
        
        for sequence in sequences:
            sequence_name = str(sequence.get('number', 1)).zfill(3)  # Default to sequence number if name is not provided
            if not sequence_name:
                sequence_name = "001"  # Default sequence name
            
            # Create sequence directory
            sequence_path = f"{episode_path}/sq{sequence_name}"
            if not unreal.EditorAssetLibrary.does_directory_exist(sequence_path):
                success = unreal.EditorAssetLibrary.make_directory(sequence_path)
                if success:
                    print(f"Created sequence directory: {sequence_path}")
                else:
                    print(f"Failed to create sequence directory: {sequence_path}")
                    continue
            
            # Create shots directory
            shots_path = f"{sequence_path}/shots"
            if not unreal.EditorAssetLibrary.does_directory_exist(shots_path):
                success = unreal.EditorAssetLibrary.make_directory(shots_path)
                if success:
                    print(f"Created shots directory: {shots_path}")
                else:
                    print(f"Failed to create shots directory: {shots_path}")
                    continue
            
            # Create individual shot directories
            shots = sequence.get('shots', [])
            for shot in shots:
                shot_code = shot.get('name')
                if shot_code:
                    shot_path = f"{shots_path}/sh{shot_code}"
                    if not unreal.EditorAssetLibrary.does_directory_exist(shot_path):
                        success = unreal.EditorAssetLibrary.make_directory(shot_path)
                        if success:
                            print(f"Created shot directory: {shot_path}")
                        else:
                            print(f"Failed to create shot directory: {shot_path}")
                else:
                    print(f"Shot code not found for shot: {shot}")

def get_existing_level_sequence(sequence_name, package_path):
    """
    Check if a level sequence already exists and return it if found.
    
    Args:
        sequence_name (str): Name of the sequence
        package_path (str): Package path where the sequence should be located
    
    Returns:
        Level sequence object if exists, None otherwise
    """
    if not UNREAL_AVAILABLE:
        return None
    
    try:
        # Construct the full asset path
        full_asset_path = f"{package_path}/{sequence_name}.{sequence_name}"
        
        # Check if the asset exists
        if unreal.EditorAssetLibrary.does_asset_exist(full_asset_path):
            # Load and return the existing asset
            existing_sequence = unreal.EditorAssetLibrary.load_asset(full_asset_path)
            if existing_sequence and isinstance(existing_sequence, unreal.LevelSequence):
                print(f"Found existing level sequence: {sequence_name} at {package_path}")
                return existing_sequence
        
        return None
        
    except Exception as e:
        print(f"Error checking for existing level sequence '{sequence_name}': {e}")
        return None

def create_level_sequence(sequence_name, package_path, skip_if_exists=True):
    """
    Create a new Level Sequence using official Unreal API.
    If skip_if_exists is True, will return existing sequence instead of creating a new one.
    """
    if not UNREAL_AVAILABLE:
        print("Cannot create level sequence: Unreal Engine API not available")
        return None
    
    # Check if sequence already exists (if skip_if_exists is enabled)
    if skip_if_exists:
        existing_sequence = get_existing_level_sequence(sequence_name, package_path)
        if existing_sequence:
            return existing_sequence
    
    try:
        # Get asset tools
        asset_tools = unreal.AssetToolsHelpers.get_asset_tools()
        
        # Create Level Sequence
        level_sequence = asset_tools.create_asset(
            asset_name=sequence_name, 
            package_path=package_path, 
            asset_class=unreal.LevelSequence, 
            factory=unreal.LevelSequenceFactoryNew()
        )
        
        if level_sequence:
            print(f"Created new level sequence: {sequence_name} at {package_path}")
            return level_sequence
        else:
            print(f"Failed to create level sequence: {sequence_name}")
            return None
            
    except Exception as e:
        print(f"Error creating level sequence '{sequence_name}': {e}")
        return None

def setup_sequence_frame_range(level_sequence, start_frame, end_frame, fps):
    """
    Set the playback frame range for a level sequence
    """
    if not UNREAL_AVAILABLE or not level_sequence:
        return False
    
    try:
        # Set the display rate
        level_sequence.set_display_rate(fps)
        level_sequence.set_playback_start(start_frame)
        level_sequence.set_playback_end(end_frame)
        # View frames
        start_sec = start_frame * fps.denominator / fps.numerator
        end_sec = end_frame * fps.denominator / fps.numerator
        level_sequence.set_view_range_start(start_sec)
        level_sequence.set_view_range_end(end_sec)
        level_sequence.set_work_range_start(start_frame)
        level_sequence.set_work_range_end(end_frame)
        print(f"Set frame range: {start_frame}-{end_frame} for sequence")
        return True
    except Exception as e:
        print(f"Error setting frame range: {e}")
        return False

def create_subsequence_track_and_section(parent_sequence, sub_sequence, start_time=0, end_time=None, track=None):
    """
    Add a sub-sequence track and section to a parent sequence
    """
    if not UNREAL_AVAILABLE or not parent_sequence or not sub_sequence:
        return None
    
    try:
        # Add a sub-sequence track to the parent
        sub_track = track or parent_sequence.add_track(unreal.MovieSceneSubTrack)
        
        # Add a section to the track
        sub_section = sub_track.add_section()
        # Set the section range
        if end_time is None:
            end_time = sub_sequence.get_playback_end()
        sub_section.set_range(start_time, end_time)
        
        # Set the sub-sequence reference
        sub_section.set_sequence(sub_sequence)
        
        print(f"Added sub-sequence to parent at time {start_time}-{end_time}")
        return sub_section
        
    except Exception as e:
        print(f"Error creating sub-sequence track: {e}")
        return None

def add_shot_markers_to_sequence(level_sequence, shots, clear_existing=False):
    """
    Add markers to mark the start and end of each shot in the sequence.
    
    Args:
        level_sequence: The level sequence to add markers to
        shots: List of shot data containing name, inFrame, outFrame
        clear_existing (bool): Whether to clear existing shot markers first
    """
    if not UNREAL_AVAILABLE or not level_sequence or not shots:
        return
    
    try:
        # Clear existing shot markers if requested
        if clear_existing:
            existing_markers = level_sequence.get_marked_frames()
            indices_to_remove = []
            
            for i, marker in enumerate(existing_markers):
                marker_label = str(marker.label)
                # Remove markers that appear to be shot markers (contain "START" or "END")
                for shot in shots:
                    if shot.get('tecnicalName') == marker_label:
                        indices_to_remove.append(i)
                        break
            
            # Remove in reverse order to maintain correct indices
            for index in reversed(indices_to_remove):
                level_sequence.delete_marked_frame(index)
                
            print(f"Cleared {len(indices_to_remove)} existing shot markers")
        
        # Add markers for each shot
        markers_added = 0
        for shot in shots:
            shot_name = shot.get('tecnicalName') or shot.get('code') or shot.get('name', 'Unknown')
            shot_in_frame = shot.get('inFrame')
            shot_out_frame = shot.get('outFrame')
            
            # Skip shots without proper frame data
            if shot_in_frame is None or shot_out_frame is None:
                print(f"Skipping shot {shot_name}: missing frame data")
                continue
            
            # Create start marker
            start_marker = unreal.MovieSceneMarkedFrame()
            start_marker.set_editor_property("frame_number", unreal.FrameNumber(shot_in_frame * 1000))
            start_marker.set_editor_property("label", shot_name)
            level_sequence.add_marked_frame(start_marker)
            print(f"Marker created with name {start_marker.get_editor_property('label')} at frame {start_marker.get_editor_property('frame_number')}")
            markers_added += 1
            
            print(f"Added markers for shot {shot_name}: frames {shot_in_frame}-{shot_out_frame}")
        
        print(f"Successfully added {markers_added} shot markers to sequence")
        
    except Exception as e:
        print(f"Error adding shot markers to sequence: {e}")

def build_project_sequences(project_name=None, shot_tasks=[], force_seq_lvl_creation=True):
    """
    Main function to build the complete Unreal project sequence structure for the current project
    
    Args:
        project_name (str): Name of the .uproject file. If None, will try to detect from Unreal context
    """
    if not UNREAL_AVAILABLE:
        print("Cannot build sequences: Unreal Engine API not available")
        return
    
    print("Starting sequence builder...")
    
    # Get the episode code for this project
    if project_name is not None:
        episode_data = get_project_episode(project_name)
        if not episode_data:
            print(f"No episode found for project: {project_name}")
            return
        episode_code = episode_data.get('code')
        episode_key = episode_data.get('key')
        print(f"Found episode code: {episode_data.get('code')} for project: {project_name}")
    else:
        episode_code = None
        episode_key = None

# Get sequences only for this episode
    project_data = get_project_data(episode_key)
    episodes = project_data.get('episodes', [])
    if episode_code is not None:
        episodes = [ep for ep in episodes if ep.get('code') == episode_code]

if not episodes:
        print(f"No episodes found for code: {episode_code}")
        return
    
    if len(episodes) > 1:
        print(f"Warning: Multiple episodes found for code {episode_code}, using first one")
    
    episode = episodes[0]  # Should only be one episode with this code
    
    # Get project FPS
    project_fps = fps_string_to_fraction(project_data.get('fps', '24'))

# Create directory structure (pass single episode in list for compatibility)
    create_sequence_directory_structure([episode])
    
    # Process the current project's episode
    episode_code = episode.get('code')
    episode_fullcode = episode.get('fullcode', episode_code)
    sequences = episode.get('sequences', [])
    
    print(f"Processing episode: {episode_fullcode}")
    
    for sequence in sequences:
        sequence_name = str(sequence.get('number', 1)).zfill(3)
        sequence_technical_name = sequence.get('tecnicalName')
        shots = sequence.get('shots', [])
        
        # TODO Filter out invalid shots
        valid_shots = shots
        
        if not valid_shots:
            print(f"No valid shots found for sequence {sequence_name}, skipping...")
            continue
        
        # Create main sequence
        main_sequence_name = sequence_technical_name
        main_sequence_path = f"/Game/Episodes/ep{episode_code}/sq{sequence_name}"
        
        # Check if main sequence already exists before creating
        existing_main_sequence = get_existing_level_sequence(main_sequence_name, main_sequence_path)
        is_main_sequence_new = existing_main_sequence is None
        
        main_sequence = create_level_sequence(main_sequence_name, main_sequence_path)
        if not main_sequence:
            continue
        
        # Calculate total sequence duration
        start_seq_frame= min(shot.get('inFrame', 0) for shot in valid_shots)
        end_seq_frame = max(shot.get('outFrame', 1001) for shot in valid_shots)
        
        # Only setup frame range for newly created sequences
        if is_main_sequence_new:
            setup_sequence_frame_range(main_sequence, start_seq_frame, end_seq_frame, project_fps)
            # Add shot markers to the main sequence
            add_shot_markers_to_sequence(main_sequence, valid_shots)
        else:
            # For existing sequences, update markers with new frame ranges
            add_shot_markers_to_sequence(main_sequence, valid_shots, clear_existing=True)

total_duration = end_seq_frame - start_seq_frame + 1
        for shot_task in shot_tasks:
            # Create lighting sub-sequence
            task_sequence_name = f"{main_sequence_name}_{shot_task}"
            
            # Check if task sequence already exists
            existing_task_sequence = get_existing_level_sequence(task_sequence_name, main_sequence_path)
            is_task_sequence_new = existing_task_sequence is None
            
            task_sequence = create_level_sequence(task_sequence_name, main_sequence_path)
            if task_sequence:
                # Only setup frame range and add to parent for newly created sequences
                if is_task_sequence_new:
                    setup_sequence_frame_range(task_sequence, start_seq_frame, end_seq_frame, project_fps)
                    create_subsequence_track_and_section(main_sequence, task_sequence, start_seq_frame, end_seq_frame)

# Create individual shot sequences and add them to task sequence
            current_time = 0
            # Only add new track for newly created task sequences
            if is_task_sequence_new:
                shots_track = task_sequence.add_track(unreal.MovieSceneSubTrack)
            else:
                # For existing sequences, try to get existing track or create new one
                existing_tracks = task_sequence.get_tracks()
                shots_track = None
                for track in existing_tracks:
                    if isinstance(track, unreal.MovieSceneSubTrack):
                        shots_track = track
                        break
                if not shots_track:
                    shots_track = task_sequence.add_track(unreal.MovieSceneSubTrack)
                    
            for shot in valid_shots:
                shot_technical_name = shot.get('tecnicalName') or shot.get('code')
                shot_code = shot.get('name')
                shot_start = shot.get('startFrame', 1001)
                shot_end = shot.get('endFrame', 1002)
                shot_seq_in = shot.get('inFrame')
                shot_seq_out = shot.get('outFrame')
                shot_duration = shot_end - shot_start + 1
                # Check in case the shot do not have in and out in sequence timeline
                if shot_seq_in is None or shot_seq_out is None:
                    shot_seq_in = current_time + 1
                    shot_seq_out = current_time + shot_duration
                # Create shot sequence in shots folder
                shot_path = f"/Game/Episodes/ep{episode_code}/sq{sequence_name}/shots/sh{shot_code}"

# Detect shot task
                current_shot_tasks = shot.get('tasks', [])
                current_task = [t for t in current_shot_tasks if t.get('maintask', {}).get('tecnicalName') == shot_task ]
                if not current_task and not force_seq_lvl_creation:
                    print(f"No valid task found for shot {shot_technical_name}, skipping...")
                    continue
                if not current_task:
                    task_technicalName = f"{shot_technical_name}_{shot_task}"
                else:
                    current_task = current_task[0]
                    task_technicalName = current_task.get('code')

if current_task:
                    light_shot_output_path = get_light_shot_task_output_path(current_task)
                    if light_shot_output_path:
                        shot_start_offset =  shot_start - shot_seq_in
                        # Create render job template for this shot
                        # Use main_sequence (global sequence) with shot's sequence timeline frames
                        create_render_job_template(
                            shot_technical_name,
                            main_sequence,  # Use main sequence instead of task_shot_sequence
                            light_shot_output_path,
                            shot_seq_in,    # Use sequence timeline frames
                            shot_seq_out,   # Use sequence timeline frames
                            shot_start_offset,
                            shot_path
                        )
                        print(f"Render job template created for shot {shot_technical_name}")
                    else:
                        print(f"Warning: No Light Shot task found for shot {shot_technical_name}, skipping render job creation")
                
                # Check if shot sequence already exists
                existing_shot_sequence = get_existing_level_sequence(task_technicalName, shot_path)
                is_shot_sequence_new = existing_shot_sequence is None
                
                task_shot_sequence = create_level_sequence(task_technicalName, shot_path)

if task_shot_sequence:
                    # Only setup frame range for newly created shot sequences
                    if is_shot_sequence_new:
                        # Set individual shot frame range
                        setup_sequence_frame_range(task_shot_sequence, shot_start, shot_end + 1, project_fps)

# Add shot to task sequence with concatenated timeline
                        if task_sequence:
                            create_subsequence_track_and_section(
                                task_sequence,
                                task_shot_sequence,
                                shot_seq_in,
                                shot_seq_out + 1,
                                shots_track
                            )
                    
                    current_time = shot_seq_out
                    
                    # Print different messages for new vs existing sequences
                    if is_shot_sequence_new:
                        print(f"Created shot sequence: {shot_technical_name} ({shot_start}-{shot_end}) and "
                            f"placed in sequence ({shot_seq_in}-{shot_seq_out})")
                    else:
                        print(f"Found existing shot sequence: {shot_technical_name} - skipping setup operations")
                    
                    # Load shot task material (always do this for both new and existing)
                    # Cameras
                    if current_task:
                        load_task_cameras(current_task.get("key"), task_shot_sequence, shot_path)
                    # Caches
                    if current_task:
                        load_task_caches(current_task.get("key"), task_shot_sequence, shot_path)

# Refresh UI to show changes
    try:
        unreal.LevelSequenceEditorBlueprintLibrary.refresh_current_level_sequence()
        print("Sequence builder completed successfully!")
        unreal.EditorDialog.show_message("Sequence Builder", "Sequence builder completed successfully!", unreal.AppMsgType.OK)
    except:
        print("Sequence builder completed (UI refresh failed)")

def get_project_name():
    project_path = unreal.Paths.get_project_file_path()
    if project_path:
        # Extract project name from the .uproject file path
        project_name = os.path.basename(project_path)
        return project_name
    return None

def build_current_episode(shot_tasks):
    project_name = get_project_name()
    if project_name:
        build_project_sequences(project_name, shot_tasks=shot_tasks)
    else:
        print("No project name found.")

build_current_episode(shot_tasks=shot_tasks)

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go