code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Check Ref Version

Jorge Hernandez Ibañez 07/10/2025

Tags
download remote references import

Check Ref Version

Jorge Herna…

Action v1

07/10/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import maya.cmds as cmds
import os
import sys

from krakenPlugin.utils.api.files import get_file_data, get_file_newer_version
from krakenPlugin.utils.downloads import download_when_required

def get_maya_references():
    """
    Get all external Maya references in the current scene.
    
    Returns:
        list: List of reference file paths
    """
    try:
        # Get all reference nodes
        ref_nodes = cmds.ls(type='reference')
        ref_files = []
        
        for ref_node in ref_nodes:
            # Skip the sharedReferenceNode
            if ref_node == 'sharedReferenceNode':
                continue
                
            try:
                # Get the reference file path
                ref_file = cmds.referenceQuery(ref_node, filename=True, withoutCopyNumber=True)
                if ref_file and os.path.isabs(ref_file):
                    ref_files.append(ref_file)
            except Exception as e:
                print(f"Error querying reference {ref_node}: {e}")
                continue
                
        return ref_files
    except Exception as e:
        print(f"Error getting Maya references: {e}")
        return []

def get_references_with_newer_versions(ref_files):
    """
    Check all reference files for newer versions.
    
    Args:
        ref_files (list): List of reference file paths
        
    Returns:
        list: List of dictionaries containing reference info and newer version data
    """
    refs_with_newer_versions = []
    
    for ref_file in ref_files:
        try:
            # Extract filename from path
            filename = os.path.basename(ref_file)
            
            # Check for newer versions using the new function
            newer_versions = get_file_newer_version(filename=filename)
            
            if newer_versions:
                # Found newer versions - store reference info
                ref_info = {
                    'original_path': ref_file,
                    'filename': filename,
                    'newer_versions': newer_versions
                }
                refs_with_newer_versions.append(ref_info)
                print(f"Found {len(newer_versions)} newer version(s) for reference: {filename}")
            else:
                print(f"Reference is up to date: {filename}")
                
        except Exception as e:
            print(f"Error checking newer versions for {ref_file}: {e}")
            continue
            
    return refs_with_newer_versions

def check_process():
    """
    Check if all Maya references are using the latest versions.
    
    Returns:
        tuple: (check_result: bool, check_error: str or False)
    """
    try:
        # Get all Maya references
        ref_files = get_maya_references()
        
        if not ref_files:
            # No references found, check passes
            return True, False
            
        # Check for newer versions
        refs_with_newer_versions = get_references_with_newer_versions(ref_files)
        
        if refs_with_newer_versions:
            # Found references with newer versions
            ref_names = [ref['filename'] for ref in refs_with_newer_versions]
            error_msg = f"Found {len(refs_with_newer_versions)} reference(s) with newer versions: {', '.join(ref_names)}"
            return False, error_msg
        else:
            # All references are up to date
            return True, False
            
    except Exception as e:
        return False, f"Error checking reference versions: {str(e)}"

def select_process():
    """
    Select Maya references that have newer versions available.
    
    Returns:
        tuple: (select_result: bool, select_error: str or False)
    """
    try:
        # Get all Maya references
        ref_files = get_maya_references()
        
        if not ref_files:
            return True, False
            
        # Check for newer versions
        refs_with_newer_versions = get_references_with_newer_versions(ref_files)
        
        outdated_ref_nodes = []
        
        # Find reference nodes that have newer versions
        for ref_info in refs_with_newer_versions:
            ref_path = ref_info['original_path']
            
            # Find the reference node for this file
            ref_nodes = cmds.ls(type='reference')
            for ref_node in ref_nodes:
                if ref_node == 'sharedReferenceNode':
                    continue
                try:
                    ref_file = cmds.referenceQuery(ref_node, filename=True, withoutCopyNumber=True)
                    if ref_file == ref_path:
                        outdated_ref_nodes.append(ref_node)
                        break
                except:
                    continue
        
        if outdated_ref_nodes:
            # Select the outdated reference nodes
            cmds.select(outdated_ref_nodes, replace=True)
            print(f"Selected {len(outdated_ref_nodes)} reference(s) with newer versions")
            return True, False
        else:
            # Clear selection if no outdated references
            cmds.select(clear=True)
            return True, False
            
    except Exception as e:
        return False, f"Error selecting outdated references: {str(e)}"

def fix_process():
    """
    Download newer versions and update Maya references to use them.
    
    Returns:
        bool: True if fix was successful, False otherwise
    """
    try:
        # Get all Maya references
        ref_files = get_maya_references()
        
        if not ref_files:
            return True
            
        # Check for newer versions
        refs_with_newer_versions = get_references_with_newer_versions(ref_files)
        
        if not refs_with_newer_versions:
            print("No references with newer versions found")
            return True
        
        updated_refs = []
        
        # Process each reference that has newer versions
        for ref_info in refs_with_newer_versions:
            try:
                original_path = ref_info['original_path']
                filename = ref_info['filename']
                newer_versions = ref_info['newer_versions']
                
                # Use the first newer version (should be the best one based on priority)
                if not newer_versions:
                    continue
                    
                newer_file = newer_versions[0]
                newer_filename = newer_file.get('fileName')
                
                if not newer_filename:
                    print(f"Warning: No filename found in newer version data for {filename}")
                    continue
                
                print(f"Updating reference from {filename} to {newer_filename}")
                
                # Get file data for the newer version to get download link
                newer_file_data = get_file_data(newer_filename, extra_data=[
                    "fileSize", "link", "lastUpdate", "pathToFile", "fileLocal"
                ])
                
                if not newer_file_data:
                    print(f"Warning: Could not get file data for newer version {newer_filename}")
                    continue
                
                # Determine the new local path
                new_local_path = newer_file_data.get('fileLocal') or newer_file_data.get('pathToFile')
                download_link = newer_file_data.get('link')
                last_update = newer_file_data.get('lastUpdate')
                
                if not new_local_path:
                    print(f"Warning: No local path found for newer version {newer_filename}")
                    continue
                
                # Download the newer version if needed
                if download_link:
                    downloaded_path = download_when_required(
                        new_local_path, 
                        download_link, 
                        file_date=last_update
                    )
                    if downloaded_path:
                        print(f"Downloaded newer version to: {downloaded_path}")
                else:
                    print(f"No download needed, using existing file: {new_local_path}")
                
                # Find and update the reference node
                ref_nodes = cmds.ls(type='reference')
                for ref_node in ref_nodes:
                    if ref_node == 'sharedReferenceNode':
                        continue
                    try:
                        ref_file = cmds.referenceQuery(ref_node, filename=True, withoutCopyNumber=True)
                        if ref_file == original_path:
                            # Replace the reference with the newer version
                            cmds.file(new_local_path, loadReference=ref_node)
                            print(f"Updated reference {ref_node} to newer version: {newer_filename}")
                            updated_refs.append(ref_node)
                            break
                    except Exception as e:
                        print(f"Warning: Failed to update reference {ref_node}: {e}")
                        continue
                        
            except Exception as e:
                print(f"Error processing reference {ref_info.get('filename', 'unknown')}: {e}")
                continue
        
        if updated_refs:
            print(f"Successfully updated {len(updated_refs)} reference(s) to newer versions")
            return True
        else:
            print("No references were updated")
            return False
            
    except Exception as e:
        print(f"Error fixing reference versions: {str(e)}")
        return False

#---------------------------------------------------------------------------------------------
def check(): # UI Functions, dont change
    check_result, check_error = check_process()
    
    if check_result:
        return True
    else:
        return check_error

def select():
    select_result, select_error = select_process()
    
    if select_result:
        return True
    else:
        return select_error

def fix(): # UI Functions, dont change
    fix_result = fix_process()
    check_result = check()
    return fix_result, check_result

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go