code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Texture Last Version Check

Jorge Hernandez Ibañez 28/08/2025

Tags

Texture Last Version Check

Jorge Herna…

Action v1

28/08/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import pipelinepro
import os
import maya.cmds as cmds
import re

def search_files(file_list, ignore_deleted=True):
    """
    Query the pipeline platform for file search information based on a list of filenames.
    
    This function constructs a GraphQL query to retrieve file data for multiple files
    simultaneously. It normalizes filename keys by replacing dots with underscores
    to ensure valid GraphQL field names.
    
    Args:
        file_list (list): List of filename strings to query for
        ignore_deleted (bool): If True, filters out deleted files from results. Defaults to True.
        
    Returns:
        dict: Response from the pipeline platform containing file information.
              Each key is a normalized filename (dots replaced with underscores).
              Each value is a list of file objects with the following structure:
              - fileName (str): The actual filename with version information
              - key (str): Unique identifier for the file
              - deleted (str|None): ISO timestamp if file is deleted, None if active
              - fileLocal (str): Local filesystem path to the file
              - pathToFile (str): Path to the file location
              - folder (dict): Contains version information:
                  - review (int|None): Review version number
                  - wip (int|None): Work-in-progress version number
              
    Example:
        >>> files = search_files(["TVFX_EL_0007_cube2_model_Face1.jpg"])
        >>> # Returns something like:
        >>> {
        >>>     "TVFX_EL_0007_cube2_model_Face1_jpg": [
        >>>         {
        >>>             "fileName": "TVFX_EL_0007_cube2_model_Face1_r002.jpg",
        >>>             "key": "AytTLkXnsD3bOcRvRAQUbmBhodmvSGX6QurIdFCRWnEKa",
        >>>             "deleted": null,
        >>>             "fileLocal": "D:/.../scene/r002/TVFX_EL_0007_cube2_model_Face1_r002.jpg",
        >>>             "pathToFile": "D:/.../scene/r002/TVFX_EL_0007_cube2_model_Face1_r002.jpg",
        >>>             "folder": {
        >>>                 "review": 2,
        >>>                 "wip": null
        >>>             }
        >>>         },
        >>>         {
        >>>             "fileName": "TVFX_EL_0007_cube2_model_Face1_r002.jpg",
        >>>             "key": "ouPjd1GeUZcDdEatzelePjGO3GWpI1edysWMzOeYODKXh",
        >>>             "deleted": "2025-08-27T13:29:57.169121+00:00",
        >>>             "fileLocal": "D:/.../scene/r003/w0001/TVFX_EL_0007_cube2_model_Face1_r002.jpg",
        >>>             "pathToFile": "D:/.../scene/r002/TVFX_EL_0007_cube2_model_Face1_r002.jpg",
        >>>             "folder": {
        >>>                 "review": 3,
        >>>                 "wip": 1
        >>>             }
        >>>         }
        >>>     ]
        >>> }
  }
    """
    query = "query{\n"
    for filename in file_list:
        filename_key = filename.replace(".", "_")
        process_filename = os.path.splitext(filename)[0]
        query += f"  {filename_key}: fileSearch(fileName:\"{process_filename}\","
        query += " token:\"{token}\"){\n    fileName\n    key\n    deleted\n"
        query += "    fileLocal\n    pathToFile\n"
        query += "    folder{\n      review\n      wip\n    }\n  }\n"
    query += "}"

response = pipelinepro.query(query)
    if ignore_deleted:
        result = {}
        # Filter out deleted files from the response
        for f_key, f_list in response.items():
            for f in f_list:
                if f.get("deleted") is None:
                    result.setdefault(f_key, []).append(f)
    else:
        result = response
    return result

def get_scene_textures():
    """
    Get all unique texture files used in the current Maya scene
    
    Returns:
        list: List of dictionaries containing unique texture information:
            - nodes: List of Maya texture node names using this texture
            - name: Display name (filename)  
            - path: Full file path
            - exists: Boolean indicating if file exists
    """
    texture_map = {}  # Dictionary to store unique textures by path
    
    try:
        # Get all file texture nodes in the scene
        file_nodes = cmds.ls(type='file') or []
        
        for node in file_nodes:
            try:
                # Get the texture file path
                file_path = cmds.getAttr(f"{node}.fileTextureName") or ""
                
                if not file_path:
                    continue
                
                # Normalize path for consistent comparison
                normalized_path = os.path.normpath(file_path)
                
                # Get the filename for display
                filename = os.path.basename(file_path)
                
                # Check if file exists
                file_exists = os.path.isfile(file_path) if file_path else False
                
                # Add or update texture entry
                if normalized_path in texture_map:
                    # Texture already exists, add this node to the list
                    texture_map[normalized_path]['nodes'].append(node)
                else:
                    # New texture, create entry
                    texture_map[normalized_path] = {
                        'nodes': [node],
                        'name': filename,
                        'path': file_path,  # Keep original path format
                        'exists': file_exists
                    }
                
            except Exception as e:
                print(f"Error processing texture node '{node}': {e}")
                continue
                
    except Exception as e:
        print(f"Error getting scene textures: {e}")
        
    # Convert dictionary to list
    return list(texture_map.values())

def parse_texture_name(filename):
    """
    Parse texture filename to extract base name, review, and wip numbers.
    
    Args:
        filename (str): The texture filename to parse
        
    Returns:
        tuple: (base_name, review_num, wip_num)
            - base_name (str): The base texture name without version suffixes
            - review_num (int|None): Review number if present, None otherwise
            - wip_num (int|None): WIP number if present, None otherwise
    
    Examples:
        parse_texture_name("TVFX_EL_0007_cube2_model_Face1_r002.jpg") 
        # Returns: ("TVFX_EL_0007_cube2_model_Face1", 2, None)
        
        parse_texture_name("TVFX_EL_0007_cube2_model_Face1_r003_w0001.jpg") 
        # Returns: ("TVFX_EL_0007_cube2_model_Face1", 3, 1)
        
        parse_texture_name("TVFX_EL_0007_cube2_model_Face1.jpg") 
        # Returns: ("TVFX_EL_0007_cube2_model_Face1", None, None)
    """
    # Remove file extension
    filename_without_ext = os.path.splitext(filename)[0]
    
    # Regex pattern to capture base name, review, and wip
    # Pattern: ^(.+?)(?:_r(\d+))?(?:_w(\d+))?$
    # Group 1: base name (non-greedy)
    # Group 2: review number (optional)
    # Group 3: wip number (optional)
    pattern = r'^(.+?)(?:_r(\d+))?(?:_w(\d+))?$'
    match = re.match(pattern, filename_without_ext)
    
    if match:
        base_name = match.group(1)
        review_str = match.group(2)
        wip_str = match.group(3)
        
        review_num = int(review_str) if review_str else None
        wip_num = int(wip_str) if wip_str else None
        
        return base_name, review_num, wip_num
    else:
        # If pattern doesn't match, return the whole filename as base
        return filename_without_ext, None, None

def find_latest_version(file_matches):
    """
    Find the latest version from a list of file matches returned by search_files.
    
    Args:
        file_matches (list): List of file objects from search_files response
        
    Returns:
        dict|None: File object with the latest version, or None if no valid files
        
    Version priority rules:
    - Files with wip != None are ignored (no updates to WIP versions)
    - review = None has highest priority (latest version)
    - Higher review numbers are newer than lower ones
    """
    if not file_matches:
        return None
    
    # Filter out files with wip != None (ignore WIP versions)
    valid_files = []
    for file_obj in file_matches:
        folder = file_obj.get('folder', {})
        wip = folder.get('wip')
        
        if wip is None:  # Only consider files without WIP versions
            valid_files.append(file_obj)
    
    if not valid_files:
        return None
    
    # Find the file with the highest review version
    latest_file = None
    latest_review = -1  # Start with -1 so any actual review number is higher
    
    for file_obj in valid_files:
        folder = file_obj.get('folder', {})
        review = folder.get('review')
        
        if review is None:
            # review = None has highest priority, return immediately
            return file_obj
        
        if review > latest_review:
            latest_review = review
            latest_file = file_obj
    
    return latest_file

def check_process():
    """
    Check if all textures in the Maya scene are using the latest available versions.
    
    Returns:
        tuple: (check_result: bool, check_error: str/False)
            - check_result: True if all textures are latest versions, False if any are outdated
            - check_error: Error message if check fails, False if successful
    """
    try:
        # Get all scene textures
        scene_textures = get_scene_textures()
        
        if not scene_textures:
            print_to_console("No textures found in the Maya scene.")
            return True, False  # No textures means check passes
        
        print(f"Checking {len(scene_textures)} texture(s) for newer versions...")
        
        # Collect base names for search
        base_names = []
        texture_data = []
        
        for texture in scene_textures:
            texture_name = texture['name']
            base_name, current_review, current_wip = parse_texture_name(texture_name)
            
            base_names.append(base_name)
            texture_data.append({
                'texture': texture,
                'base_name': base_name,
                'current_review': current_review,
                'current_wip': current_wip
            })
        
        # Search for all versions using base names
        platform_response = search_files(base_names, ignore_deleted=True)
        print(f"Platform search response: {platform_response}")
        
        # Check each texture for newer versions
        outdated_textures = []
        
        for data in texture_data:
            texture = data['texture']
            base_name = data['base_name']
            current_review = data['current_review']
            texture_name = texture['name']
            
            # Get search results for this base name
            search_key = base_name.replace(".", "_")
            file_matches = platform_response.get(search_key, [])
            
            if not file_matches:
                print(f"No versions found for texture: {texture_name}")
                continue
            
            # Find the latest available version
            latest_file = find_latest_version(file_matches)
            
            if not latest_file:
                print(f"No valid versions found for texture: {texture_name}")
                continue
            
            # Get latest version info
            latest_folder = latest_file.get('folder', {})
            latest_review = latest_folder.get('review')
            latest_filename = latest_file.get('fileName', '')
            
            # Compare versions
            is_outdated = False
            
            if latest_review is None and current_review is not None:
                # Latest has no version (review=None), current has version number
                is_outdated = True
            elif latest_review is not None and current_review is not None:
                # Both have version numbers, compare them
                if latest_review > current_review:
                    is_outdated = True
            # If current_review is None, we're already using the latest
            
            if is_outdated:
                outdated_textures.append({
                    'current': texture_name,
                    'latest': latest_filename,
                    'current_review': current_review,
                    'latest_review': latest_review
                })
        
        # Report results
        if outdated_textures:
            msg = f"Found {len(outdated_textures)} texture(s) with newer versions available:\n"
            for item in outdated_textures:
                msg += f"  - Current: {item['current']} (r{item['current_review']})\n"
                msg += f"    Latest:  {item['latest']} (r{item['latest_review'] if item['latest_review'] is not None else 'None'})\n"
            return False, msg
        else:
            print(f"All {len(scene_textures)} texture(s) are using the latest available versions.")
            return True, False
            
    except Exception as e:
        error_msg = f"Error checking texture versions: {str(e)}"
        print(error_msg)
        return False, error_msg

def select_process():
    """
    Select Maya texture nodes that are using outdated texture versions.
    
    Returns:
        tuple: (select_result: bool, select_error: str/False)
            - select_result: True if selection successful, False if error
            - select_error: Error message if selection fails, False if successful
    """
    try:
        # Get all scene textures
        scene_textures = get_scene_textures()
        
        if not scene_textures:
            print("No textures found in the Maya scene.")
            return True, False  # No textures to select
        
        print(f"Checking {len(scene_textures)} texture(s) for outdated versions...")
        
        # Collect base names for search
        base_names = []
        texture_data = []
        
        for texture in scene_textures:
            texture_name = texture['name']
            base_name, current_review, current_wip = parse_texture_name(texture_name)
            
            base_names.append(base_name)
            texture_data.append({
                'texture': texture,
                'base_name': base_name,
                'current_review': current_review,
                'current_wip': current_wip
            })
        
        # Search for all versions using base names
        platform_response = search_files(base_names, ignore_deleted=True)
        print(f"Platform search response: {platform_response}")
        
        # Find textures with outdated versions and collect their nodes
        outdated_nodes = []
        outdated_textures = []
        
        for data in texture_data:
            texture = data['texture']
            base_name = data['base_name']
            current_review = data['current_review']
            texture_name = texture['name']
            
            # Get search results for this base name
            search_key = base_name.replace(".", "_")
            file_matches = platform_response.get(search_key, [])
            
            if not file_matches:
                continue
            
            # Find the latest available version
            latest_file = find_latest_version(file_matches)
            
            if not latest_file:
                continue
            
            # Get latest version info
            latest_folder = latest_file.get('folder', {})
            latest_review = latest_folder.get('review')
            
            # Compare versions
            is_outdated = False
            
            if latest_review is None and current_review is not None:
                # Latest has no version (review=None), current has version number
                is_outdated = True
            elif latest_review is not None and current_review is not None:
                # Both have version numbers, compare them
                if latest_review > current_review:
                    is_outdated = True
            
            if is_outdated:
                # Add nodes for this outdated texture
                outdated_nodes.extend(texture['nodes'])
                outdated_textures.append(texture_name)
        
        # Select the nodes in Maya
        if outdated_nodes:
            cmds.select(outdated_nodes, replace=True)
            print(f"Selected {len(outdated_nodes)} texture node(s) with outdated versions:")
            for texture_name in outdated_textures:
                print(f"  - {texture_name}")
            return True, False
        else:
            print("All textures are using the latest available versions. No nodes to select.")
            cmds.select(clear=True)  # Clear selection if all textures are up to date
            return True, False
            
    except Exception as e:
        error_msg = f"Error selecting outdated texture nodes: {str(e)}"
        print(error_msg)
        return False, error_msg

def fix_process():
    """
    Fix outdated texture versions by updating Maya texture paths to latest available versions.
    
    Returns:
        bool: True if fix successful, False if error occurred
    """
    try:
        # Get all scene textures
        scene_textures = get_scene_textures()
        
        if not scene_textures:
            print("No textures found in the Maya scene.")
            return True  # No textures to fix
        
        print(f"Fixing {len(scene_textures)} texture(s) to latest versions...")
        
        # Collect base names for search
        base_names = []
        texture_data = []
        
        for texture in scene_textures:
            texture_name = texture['name']
            base_name, current_review, current_wip = parse_texture_name(texture_name)
            
            base_names.append(base_name)
            texture_data.append({
                'texture': texture,
                'base_name': base_name,
                'current_review': current_review,
                'current_wip': current_wip
            })
        
        # Search for all versions using base names
        platform_response = search_files(base_names, ignore_deleted=True)
        print(f"Platform search response: {platform_response}")
        
        # Update textures with outdated versions
        updated_count = 0
        
        for data in texture_data:
            texture = data['texture']
            base_name = data['base_name']
            current_review = data['current_review']
            texture_name = texture['name']
            texture_nodes = texture['nodes']
            
            # Get search results for this base name
            search_key = base_name.replace(".", "_")
            file_matches = platform_response.get(search_key, [])
            
            if not file_matches:
                print(f"No versions found for texture: {texture_name}")
                continue
            
            # Find the latest available version
            latest_file = find_latest_version(file_matches)
            
            if not latest_file:
                print(f"No valid versions found for texture: {texture_name}")
                continue
            
            # Get latest version info
            latest_folder = latest_file.get('folder', {})
            latest_review = latest_folder.get('review')
            latest_filename = latest_file.get('fileName', '')
            
            # Compare versions
            is_outdated = False
            
            if latest_review is None and current_review is not None:
                # Latest has no version (review=None), current has version number
                is_outdated = True
            elif latest_review is not None and current_review is not None:
                # Both have version numbers, compare them
                if latest_review > current_review:
                    is_outdated = True
            
            if is_outdated:
                # Get the path to the latest version
                # Prefer pathToFile, fallback to fileLocal if pathToFile is None
                latest_path = latest_file.get('pathToFile') or latest_file.get('fileLocal')
                
                if not latest_path:
                    print(f"No file path available for latest version of: {texture_name}")
                    continue
                
                # Update all texture nodes using this texture
                for node in texture_nodes:
                    try:
                        if cmds.objExists(node):
                            cmds.setAttr(f"{node}.fileTextureName", latest_path, type="string")
                            updated_count += 1
                            print(f"Updated texture node '{node}': {texture_name} -> {latest_filename}")
                            print(f"  New path: {latest_path}")
                        else:
                            print(f"Warning: Texture node '{node}' no longer exists in the scene")
                    except Exception as e:
                        print(f"Error updating texture node '{node}': {e}")
                        continue
        
        if updated_count > 0:
            print(f"Successfully updated {updated_count} texture node(s) to latest versions.")
        else:
            print("All textures are already using the latest available versions. No updates needed.")
        
        return True
        
    except Exception as e:
        error_msg = f"Error fixing texture versions: {str(e)}"
        print(error_msg)
        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