code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Unpublished Textures Check

Jorge Hernandez Ibañez 28/08/2025

Tags
texture publish shading

Unpublished Textures Check

Jorge Herna…

Action v1

28/08/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import pipelinepro
import maya.cmds as cmds
import os

def get_files(file_list):
    """
    Query the pipeline platform for file 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
        
    Returns:
        dict: Response from the pipeline platform containing file information.
              Each file entry includes fileName and key fields.
              
    Example:
        >>> files = get_files(["blackTexture.jpg", "textureWhite.jpg"])
        >>> # Returns something like:
        >>> {
        >>>     "blackTexture_jpg": {
        >>>         "fileName": "blackTexture.jpg",
        >>>         "key": "5OGQZpz0i92DO7KGe0985nOnB7bhQpuZ3BoCThACTsLUv"
        >>>     },
        >>>     "textureWhite_jpg": {
        >>>         "fileName": "textureWhite.jpg",
        >>>         "key": "hvnPp4v07iPZfsXZS7zkp0rBBXzcROB6zfyfZVs21l1ET"
        >>>     }
        >>> }
    """
    query = "query{\n"
    for filename in file_list:
        filename_key = filename.replace(".", "_")
        query += f"  {filename_key}: file(fileName:\"{filename}\","
        query += " token:\"{token}\"){\n    fileName\n    key\n  }\n"
    query += "}"

response = pipelinepro.query(query)
    return response

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 check_process():
    """
    Check if all textures in the Maya scene are published to the platform.
    
    Returns:
        tuple: (check_result: bool, check_error: str/False)
            - check_result: True if all textures are published, False if any are unpublished
            - 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("No textures found in the Maya scene.")
            return True, False  # No textures means check passes
        
        # Get list of texture names to check
        texture_names = []
        for texture in scene_textures:
            texture_names.append(texture['name'])
        
        # Query the platform using get_files function
        platform_response = get_files(texture_names)
        print(f"Platform query response: {platform_response}")
        
        # Check which textures are unpublished
        unpublished_textures = []
        for texture in scene_textures:
            texture_name = texture['name']
            # Convert filename to key format (dots replaced with underscores)
            filename_key = texture_name.replace(".", "_")
            
            if not platform_response or platform_response.get(filename_key) is None:
                # Texture is not published
                unpublished_textures.append(texture_name)
        
        # Print results
        if unpublished_textures:
            msg = f"Found {len(unpublished_textures)} unpublished texture(s):\n"
            for texture_name in unpublished_textures:
                msg += f"  - {texture_name}\n"
            return False, msg
        else:
            print_to_console(f"All {len(scene_textures)} texture(s) are published to the platform.")
            return True, False  # Check passes if all textures are published
            
    except Exception as e:
        error_msg = f"Error checking textures: {str(e)}"
        print(error_msg)
        return False, error_msg

def select_process():
    """
    Select Maya texture nodes that have unpublished textures.
    
    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
        
        # Get list of texture names to check
        texture_names = []
        for texture in scene_textures:
            texture_names.append(texture['name'])
        
        # Query the platform using get_files function
        platform_response = get_files(texture_names)
        print(f"Platform query response: {platform_response}")
        
        # Find textures that are unpublished and collect their nodes
        unpublished_nodes = []
        unpublished_textures = []
        
        for texture in scene_textures:
            texture_name = texture['name']
            # Convert filename to key format (dots replaced with underscores)
            filename_key = texture_name.replace(".", "_")
            
            if not platform_response or platform_response.get(filename_key) is None:
                # Texture is not published, add its nodes to selection
                unpublished_nodes.extend(texture['nodes'])
                unpublished_textures.append(texture_name)
        
        # Select the nodes in Maya
        if unpublished_nodes:
            cmds.select(unpublished_nodes, replace=True)
            print(f"Selected {len(unpublished_nodes)} texture node(s) with unpublished textures:")
            for texture_name in unpublished_textures:
                print(f"  - {texture_name}")
            return True, False
        else:
            print("All textures are published. No nodes to select.")
            cmds.select(clear=True)  # Clear selection if all textures are published
            return True, False
            
    except Exception as e:
        error_msg = f"Error selecting texture nodes: {str(e)}"
        print(error_msg)
        return False, error_msg

#---------------------------------------------------------------------------------------------
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

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go