code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Texture Publisher

Jorge Hernandez Ibañez 28/08/2025

Tags

Texture Publisher

Jorge Herna…

Action v15

28/08/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import pipelinepro
import requests
import os
import json
import shutil
import maya.cmds as cmds
import maya.OpenMayaUI as omui
import re

# Try to import PySide6 first, fallback to PySide2
try:
    from PySide6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, 
                                   QPushButton, QFormLayout, QMessageBox, QCheckBox, 
                                   QTableWidget, QTableWidgetItem, QHeaderView, QAbstractItemView,
                                   QProgressBar, QApplication, QGroupBox)
    from PySide6.QtCore import Qt
    from PySide6.QtGui import QColor, QIcon
    from shiboken6 import wrapInstance
    PYSIDE_VERSION = 6
except ImportError:
    try:
        from PySide2.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, 
                                       QPushButton, QFormLayout, QMessageBox, QCheckBox, 
                                       QTableWidget, QTableWidgetItem, QHeaderView, QAbstractItemView,
                                       QProgressBar, QApplication, QGroupBox)
        from PySide2.QtCore import Qt
        from PySide2.QtGui import QColor, QIcon
        from shiboken2 import wrapInstance
        PYSIDE_VERSION = 2
    except ImportError:
        raise ImportError("Neither PySide6 nor PySide2 is available")

def maya_main_window():
    """
    Return the Maya main window widget as a Python object
    """
    main_window_ptr = omui.MQtUtil.mainWindow()
    return wrapInstance(int(main_window_ptr), QDialog)

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
            - usage: Description of where texture is used (all materials)
            - 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
                        'usage': '',  # Will be filled later
                        'exists': file_exists
                    }
                
            except Exception as e:
                print(f"Error processing texture node '{node}': {e}")
                continue
        
        # Now get usage information for each unique texture
        for texture_info in texture_map.values():
            texture_info['usage'] = get_texture_usage(texture_info['nodes'])
                
    except Exception as e:
        print(f"Error getting scene textures: {e}")
        
    # Convert dictionary to list
    return list(texture_map.values())

def get_texture_usage(texture_nodes):
    """
    Find where texture nodes are being used (materials, shaders, etc.)
    
    Args:
        texture_nodes (list or str): Maya texture node names
        
    Returns:
        str: Description of usage across all nodes
    """
    if isinstance(texture_nodes, str):
        texture_nodes = [texture_nodes]
    
    all_usage = set()  # Use set to avoid duplicates
    
    try:
        for texture_node in texture_nodes:
            try:
                # Get output connections from the texture node
                connections = cmds.listConnections(f"{texture_node}.outColor", 
                                                 destination=True, source=False) or []
                
                for conn in connections:
                    # Check if connected to a shader/material
                    node_type = cmds.nodeType(conn)
                    
                    if node_type in ['lambert', 'blinn', 'phong', 'aiStandardSurface', 'standardSurface']:
                        # It's a material/shader - just add the material name without prefix
                        all_usage.add(conn)
                    else:
                        # Some other connection
                        all_usage.add(f"Node: {conn} ({node_type})")
                        
            except Exception as e:
                print(f"Error getting usage for texture node '{texture_node}': {e}")
                continue
        
        if all_usage:
            # Convert to sorted list for consistent ordering
            usage_list = sorted(list(all_usage))
            # Limit display to avoid overly long strings
            if len(usage_list) > 5:
                return ", ".join(usage_list[:5]) + f" + {len(usage_list) - 5} more"
            else:
                return ", ".join(usage_list)
        else:
            return "Not connected"
            
    except Exception as e:
        print(f"Error getting usage for texture nodes: {e}")
        return "Unknown usage"

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_file_folder(filename):
    query = """
    query{
        file(fileName:"{filename}", token:"{token}"){
            folder{
                name
                key
            }
        }
    }
    """
    query = query.replace("{filename}", filename)
    response = pipelinepro.query(query)
    if not response or not response.get("file"):
        return None, [], None
    file_data = response["file"]
    return file_data

def get_file_tasks(filename):
    """
    Get tasks associated with a specific file

Returns:
        dict: Current file task
        list: The available tasks in the related asset/shot.
    """
    query = """
    query{
        file(fileName:"{filename}", token:"{token}"){
            shot{
                tecnicalName
                tasks{
                    name
                    key
                    code
                    maintask{
                        name
                    }
                    publishFolder{
                        key
                        name
                    }
                    folders{
                        review
                        wip
                        type
                    }
                }
            }
            asset{
                tecnicalName
                tasks{
                    name
                    key
                    code
                    maintask{
                        name
                    }
                    publishFolder{
                        key
                        name
                    }
                    folders{
                        review
                        wip
                        type
                    }
                }
            }
            task{
                name
                key
                code
                maintask{
                    name
                }
                folders{
                    review
                    wip
                    type
                }
            }
            folder{
                review
                wip
                type
                name
                key
            }
        }
    }
    """
    query = query.replace("{filename}", filename)
    response = pipelinepro.query(query)
    if not response or not response.get("file"):
        return None, None, [], None
    file_data = response["file"]
    if file_data.get("asset") is not None:
        return file_data["task"], file_data["folder"], file_data["asset"]["tasks"], file_data["asset"]["tecnicalName"]
    if file_data.get("shot") is not None:
        return file_data["task"], file_data["folder"], file_data["shot"]["tasks"], file_data["shot"]["tecnicalName"]
    return file_data["task"], file_data["folder"], [], None

def create_task_review_folder(task_key):
    mutation = """
    mutation{
        createTaskReview(taskKey:"{task_key}", token:"{token}"){
            folder{
            name
            key
            }
        }
    }
    """
    mutation = mutation.replace("{task_key}", task_key)
    try:
        response = pipelinepro.query(mutation)
    except Exception as e:
        print("Error on DB query: ", e)
        return None

return response['createTaskReview']

def create_output_folder(src_folder_key, folder_name='textures'):
    """
    Create output folder in the pipeline system
    """
    mutation = '''
    mutation{
      createSubfolder(token:"{token}", folderKey:"{folder_key}", type:"{folder_name}"){
        folder{
          name
          code
          key
          folderLocal
        }
      }
    }
    '''
    mutation = mutation.replace('{folder_key}', src_folder_key)
    mutation = mutation.replace('{folder_name}', folder_name)
    
    try:
        response = pipelinepro.query(mutation)
    except Exception as e:
        print("Error on DB query: ", e)
        return None
        
    return response['createSubfolder']

def create_file(filename, folder_key):
    """
    Create file entry in the pipeline database
    """
    mutation = '''
    mutation{
      newFile(token:"{token}", fileName:"{fileName}", folderKey:"{folderKey}"){
        file{
          fileName
          key
          uploadLink
          fileLocal
        }
      }
    }
    '''
    mutation = mutation.replace("{fileName}", filename)
    mutation = mutation.replace("{folderKey}", folder_key)
    
    try:
        response = pipelinepro.query(mutation)
    except Exception as e:
        print("Error on DB query: ", e)
        return None
        
    return response['newFile']

def data_write(model, key, field, value):
    mutation = """
    mutation{
      dataWrite(token:"{token}", model:"{model}", key:"{key}", value:{value}){
        data
      }
    }
    """
    mutation = (
        mutation.replace("{model}", model)
        .replace("{key}", key)
        .replace("{value}", json.dumps(json.dumps({field: value})))
    )
    print("mutation", mutation)
    return pipelinepro.query(mutation)

def upload_file_to_platform(filepath, upload_link, file_key=None, ghost_file=False):
    """
    Upload a file to the pipeline platform and mark it as completed in the database.
    
    This function performs a two-step process:
    1. Uploads the file content to the provided upload URL using HTTP PUT request
    2. Marks the file as completed in the platform database with metadata
    
    Args:
        filepath (str): The absolute path to the local file to be uploaded.
                       Must be a valid file path that exists on the filesystem.
        upload_link (str): The pre-signed upload URL provided by the platform.
                          This URL is typically obtained from a previous API call
                          that creates the file entry in the database.
        file_key (str, optional): The unique identifier for the file in the platform
                                 database. Required for marking the file as completed.
                                 Defaults to None.
        ghost_file (bool, optional): If True, skips the actual file upload and only
                                   marks the file as completed with size 0. Used for
                                   creating file references without actual content.
                                   Defaults to False.
    
    Returns:
        dict or None: Returns the response from the completedFile mutation containing
                     file information if successful, or None if an error occurred.
                     The response typically contains:
                     - file: dict with fileName and other file metadata
    
    Raises:
        Exception: Various exceptions may be raised during file operations:
                  - FileNotFoundError: If the filepath doesn't exist
                  - PermissionError: If insufficient permissions to read the file
                  - ConnectionError: If network issues occur during upload
                  - Any other exception during the upload or database operations
    
    Example:
        >>> file_key = "abc123def456"
        >>> upload_url = "https://platform.com/upload/signed-url"
        >>> result = upload_file_to_platform(
        ...     "/path/to/texture.jpg", 
        ...     upload_url, 
        ...     file_key=file_key
        ... )
        >>> if result:
        ...     print(f"Upload successful: {result['file']['fileName']}")
        
    Note:
        - The function uses requests.put() for uploading file content
        - File paths are normalized and converted to forward slashes for the database
        - Progress and error messages are printed to console for debugging
        - The platform token is automatically injected into GraphQL mutations
    """
    filename = os.path.basename(filepath)
    
    if not file_key:
        print("No file key provided")
        return None
        
    try:
        if not ghost_file:
            with open(filepath, "rb") as file_data:
                response = requests.put(upload_link, data=file_data)
        
        print(f"File '{filename}' uploaded successfully. Response: {response}")
        
        # Set file as completed
        mutation = '''
        mutation{
          completedFile(token:"{token}", fileKey:"{fileKey}", fileSize: {fileSize}, pathToFile:"{pathToFile}"){
            file{
              fileName
            }
          }
        }
        '''
        mutation = mutation.replace("{fileSize}", str(os.path.getsize(filepath) if not ghost_file else 0))
        mutation = mutation.replace("{pathToFile}", os.path.normpath(filepath).replace("\\", "/"))
        mutation = mutation.replace("{fileKey}", file_key)
        
        response = pipelinepro.query(mutation)
        print(f"File '{filename}' published successfully.")
        return response['completedFile']
        
    except Exception as e:
        print(f"Error uploading file: {e}")
        return None

def copy_texture_file(src_path, dest_path):
    """
    Copy texture file from source to destination
    
    Args:
        src_path (str): Source file path
        dest_path (str): Destination file path
        
    Returns:
        bool: True if successful, False otherwise
    """
    try:
        # Create destination directory if it doesn't exist
        dest_dir = os.path.dirname(dest_path)
        os.makedirs(dest_dir, exist_ok=True)
        
        # Copy the file
        shutil.copy2(src_path, dest_path)
        print(f"Copied texture: {src_path} -> {dest_path}")
        return True
        
    except Exception as e:
        print(f"Error copying texture file '{src_path}' to '{dest_path}': {e}")
        return False

def should_copy_file(source_path, dest_path):
    """
    Determine if file needs to be copied or if source equals destination
    
    Args:
        source_path (str): Source file path
        dest_path (str): Destination file path
        
    Returns:
        tuple: (needs_copy: bool, file_to_upload: str, reason: str)
    """
    try:
        # Normalize and make absolute paths for accurate comparison
        normalized_source = os.path.normpath(os.path.abspath(source_path))
        normalized_dest = os.path.normpath(os.path.abspath(dest_path))
        
        if normalized_source == normalized_dest:
            return False, source_path, "already at target location"
        else:
            return True, dest_path, "copy required"
            
    except Exception as e:
        print(f"Path comparison failed: {e}, defaulting to copy")
        return True, dest_path, "copy required (comparison failed)"

def update_texture_paths(texture_mappings):
    """
    Update Maya texture node paths to point to new published locations
    
    Args:
        texture_mappings (list): List of dicts with 'node' and 'new_path' keys
    """
    updated_count = 0
    
    for mapping in texture_mappings:
        try:
            node = mapping['node']
            new_path = mapping['new_path']
            
            # Check if the texture node still exists
            if cmds.objExists(node):
                # Update the file texture name attribute
                cmds.setAttr(f"{node}.fileTextureName", new_path, type="string")
                print(f"Updated texture path for '{node}': {new_path}")
                updated_count += 1
            else:
                print(f"Warning: Texture node '{node}' no longer exists in the scene")
                
        except Exception as e:
            print(f"Error updating texture path for node '{mapping.get('node', 'unknown')}': {e}")
    
    print(f"Updated {updated_count} texture paths in Maya")
    return updated_count

def generate_texture_new_names(textures, task_code, review=None, wip=None):
    """
    Generate new texture names with intelligent renaming and uniqueness validation
    
    Args:
        textures (list): List of texture dictionaries
        task_code (str): Task code from selected task
        
    Returns:
        dict: Mapping of original paths to new names
    """
    print(f"Computing naming with review: {review}, wip: {wip}")
    if not task_code:
        # If no task code, return original names
        return {texture['path']: texture['name'] for texture in textures}
    
    name_mapping = {}
    used_names = set()
    if review is not None and wip is not None:
        target_version = f"_r{str(review).zfill(3)}_w{str(wip).zfill(4)}"
    elif review is not None and wip is None:
        target_version = f"_r{str(review).zfill(3)}"
    else:
        target_version = None
    
    # Smart renaming: Check if texture already starts with the task code
    task_prefix = f"{task_code}_"
    
    for texture in textures:
        original_name = texture['name']
        
        # Split filename and extension
        name_parts = os.path.splitext(original_name)
        filename_without_ext = name_parts[0]
        extension = name_parts[1]

# Extract texture name by removing task prefix and version suffixes
        escaped_prefix = re.escape(task_code)
        pattern = rf'^{escaped_prefix}_(.+?)(?:_r\d+)?(?:_w\d+)?$'
        match = re.match(pattern, filename_without_ext)
        base_texture_name = match.group(1) if match else filename_without_ext        
        
        # Check if it's the exact same version review/wip
        if filename_without_ext.startswith(task_prefix) and target_version is not None and filename_without_ext.endswith(target_version):
            # Texture already has the correct prefix, keep original name
            new_name = original_name
            print(f"Texture already has correct prefix: {original_name} (keeping as-is)")
        else:
            # Texture doesn't have the prefix or we need to recompute the version, rebuild the name
            if target_version is not None:
                new_name = f"{task_prefix}{base_texture_name}{target_version}{extension}"
            else:
                new_name = f"{task_prefix}{base_texture_name}{extension}"
            print(f"Adding task prefix: {original_name} -> {new_name}")
        
        # Check for uniqueness and add index if needed
        final_name = new_name
        counter = 1
        
        while final_name in used_names:
            if target_version is not None:
                final_name = f"{task_prefix}{base_texture_name}_{counter:02d}{target_version}{extension}"
            else:
                final_name = f"{task_prefix}{base_texture_name}_{counter:02d}{extension}"
            counter += 1
        
        # Store the mapping and mark name as used
        name_mapping[texture['path']] = final_name
        used_names.add(final_name)
        
        if final_name != new_name:
            print(f"Resolved naming conflict: {new_name} -> {final_name}")
    
    return name_mapping

def update_texture_paths_multiple_nodes(texture_mappings):
    """
    Update Maya texture node paths for textures that may have multiple nodes
    
    Args:
        texture_mappings (list): List of dicts with 'nodes' (list) and 'new_path' keys
    """
    updated_count = 0
    
    for mapping in texture_mappings:
        try:
            nodes = mapping['nodes']
            new_path = mapping['new_path']
            
            for node in nodes:
                try:
                    # Check if the texture node still exists
                    if cmds.objExists(node):
                        # Update the file texture name attribute
                        cmds.setAttr(f"{node}.fileTextureName", new_path, type="string")
                        print(f"Updated texture path for '{node}': {new_path}")
                        updated_count += 1
                    else:
                        print(f"Warning: Texture node '{node}' no longer exists in the scene")
                        
                except Exception as e:
                    print(f"Error updating texture path for node '{node}': {e}")
                    
        except Exception as e:
            print(f"Error updating texture paths for mapping: {e}")
    
    print(f"Updated {updated_count} texture node paths in Maya")
    return updated_count

class TexturePublisherDialog(QDialog):
    """
    Dialog for publishing textures from Maya to the pipeline platform
    """
    
    def __init__(self, parent=maya_main_window()):
        super(TexturePublisherDialog, self).__init__(parent)
        
        # Initialize UI
        self.setWindowTitle("Texture Publisher")
        self.setMinimumSize(800, 600)
        self.setMaximumSize(1200, 800)
        
        # Store data
        self.current_file_task = None
        self.current_file_folder = None
        self.linked_entity_name = None
        self.available_tasks = []
        self.scene_textures = []
        self.output_folder = None
        self.texture_check_performed = False
        
        self.create_widgets()
        self.create_layout()
        self.create_connections()
        
        # Load data
        self.load_data()
    
    def create_widgets(self):
        """
        Create all UI widgets
        """
        # Publish in current task option
        self.publish_in_current_task_cb = QCheckBox("Publish in current task")
        self.publish_in_current_task_cb.setChecked(True)  # Checked by default
        self.publish_in_current_task_cb.setToolTip("Use the current file's task for publishing (disables task selection)")
        
        # Task selection
        self.task_label = QLabel("Publish to Task:")
        self.task_combo = QComboBox()
        self.task_combo.setToolTip("Select the task where textures will be published")
        self.task_combo.setEnabled(False)  # Initially disabled since checkbox is checked by default
        
        # Update texture paths option
        self.update_paths_cb = QCheckBox("Update texture paths on publish")
        self.update_paths_cb.setChecked(True)  # Checked by default
        self.update_paths_cb.setToolTip("Update Maya texture paths to point to published locations after publishing")
        
        # Texture renaming option
        self.texture_renaming_cb = QCheckBox("Texture Renaming")
        self.texture_renaming_cb.setChecked(True)  # Checked by default
        self.texture_renaming_cb.setToolTip("Rename textures using the selected task code for consistent naming")
        
        # Upload files to platform option
        self.upload_files_cb = QCheckBox("Upload Files to platform")
        self.upload_files_cb.setChecked(True)  # Checked by default
        self.upload_files_cb.setToolTip("Upload texture files to platform. Uncheck to create file references only (ghost files)")
        
        # Target folder selection
        self.target_folder_label = QLabel("Target Folder:")
        self.target_folder_combo = QComboBox()
        self.target_folder_combo.addItems(["scene", "textures"])
        self.target_folder_combo.setCurrentText("scene")  # Default to textures (current behavior)
        self.target_folder_combo.setToolTip("Choose publishing destination: 'scene' (direct to task folder) or 'textures' (create textures subfolder)")
        
        # Target version selection
        self.target_version_label = QLabel("Target Version:")
        self.target_version_combo = QComboBox()
        self.target_version_combo.addItems(["current", "publish", "review"])
        self.target_version_combo.setCurrentText("current")  # Default to publish (current behavior)
        self.target_version_combo.setToolTip("Choose version destination: 'current' (current file folder), 'publish' (task publish folder), or 'review' (new task review folder)")
        
        # Texture table
        self.texture_table = QTableWidget()
        self.texture_table.setColumnCount(6)
        self.texture_table.setHorizontalHeaderLabels(["Publish", "Status", "Texture Name", "New Name", "File Path", "Materials"])
        
        # Set table properties
        self.texture_table.setSelectionBehavior(QAbstractItemView.SelectRows)
        self.texture_table.setAlternatingRowColors(True)
        
        # Configure column widths
        header = self.texture_table.horizontalHeader()
        header.setSectionResizeMode(0, QHeaderView.ResizeToContents)  # Publish checkbox
        header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # Status indicator
        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # Texture name
        header.setSectionResizeMode(3, QHeaderView.ResizeToContents)  # New name
        header.setSectionResizeMode(4, QHeaderView.Stretch)           # File path (expandable)
        header.setSectionResizeMode(5, QHeaderView.ResizeToContents)  # Materials
        
        # Selection buttons
        self.select_all_button = QPushButton("Select All")
        self.clear_selection_button = QPushButton("Clear Selection")
        self.select_new_textures_button = QPushButton("Select New Textures")
        self.select_new_textures_button.setEnabled(False)  # Disabled until check is performed
        
        # Progress widgets (initially hidden)
        self.progress_bar = QProgressBar()
        self.progress_bar.setRange(0, 100)
        self.progress_bar.setValue(0)
        self.progress_bar.setVisible(False)
        
        self.progress_label = QLabel("Ready to publish...")
        self.progress_label.setVisible(False)
        self.progress_label.setAlignment(Qt.AlignCenter)
        
        # Action buttons
        self.refresh_button = QPushButton("Refresh Textures")
        self.check_textures_button = QPushButton("Check Textures")
        self.cancel_button = QPushButton("Cancel")
        self.publish_button = QPushButton("Publish Textures")
        
        # Initially disable publish button until check is performed
        self._update_publish_button_state(False)
    
    def _update_publish_button_state(self, state):
        self.publish_button.setEnabled(state)
        if not state:
            self.publish_button.setToolTip("Check textures first to enable publishing")
        else:
            self.publish_button.setToolTip("Publish the selected textures")

def create_layout(self):
        """
        Create and set the layout for the dialog
        """
        # Main layout
        main_layout = QVBoxLayout(self)
        
        # Publish Config group box
        publish_config_group = QGroupBox("Publish Config")
        publish_config_layout = QVBoxLayout(publish_config_group)
        
        # Task selection layout
        publish_config_layout.addWidget(self.publish_in_current_task_cb)
        
        # Horizontal layout for task and folder controls in same line
        controls_layout = QHBoxLayout()
        controls_layout.addWidget(self.task_label)
        controls_layout.addWidget(self.task_combo)
        controls_layout.addSpacing(20)  # Add space between task and folder controls
        controls_layout.addWidget(self.target_folder_label)
        controls_layout.addWidget(self.target_folder_combo)
        controls_layout.addSpacing(20)  # Add space between task and folder controls
        controls_layout.addWidget(self.target_version_label)
        controls_layout.addWidget(self.target_version_combo)
        controls_layout.addStretch()  # Push everything to the left
        publish_config_layout.addLayout(controls_layout)
        
        # Options layout
        publish_config_layout.addWidget(self.update_paths_cb)
        publish_config_layout.addWidget(self.texture_renaming_cb)
        publish_config_layout.addWidget(self.upload_files_cb)
        
        # Add the group box to main layout
        main_layout.addWidget(publish_config_group)
        
        # Table selection buttons layout
        table_buttons_layout = QHBoxLayout()
        table_buttons_layout.addWidget(QLabel("Textures to Publish:"))
        table_buttons_layout.addStretch()
        table_buttons_layout.addWidget(self.select_all_button)
        table_buttons_layout.addWidget(self.clear_selection_button)
        table_buttons_layout.addWidget(self.select_new_textures_button)
        
        # Progress layout
        progress_layout = QVBoxLayout()
        progress_layout.addWidget(self.progress_bar)
        progress_layout.addWidget(self.progress_label)
        
        # Action buttons layout
        action_buttons_layout = QHBoxLayout()
        action_buttons_layout.addWidget(self.refresh_button)
        action_buttons_layout.addStretch()
        action_buttons_layout.addWidget(self.check_textures_button)
        action_buttons_layout.addWidget(self.cancel_button)
        action_buttons_layout.addWidget(self.publish_button)
        
        # Add layouts to main layout
        main_layout.addLayout(table_buttons_layout)
        main_layout.addWidget(self.texture_table)
        main_layout.addLayout(progress_layout)
        main_layout.addLayout(action_buttons_layout)
    
    def create_connections(self):
        """
        Connect signals to slots
        """
        self.publish_in_current_task_cb.stateChanged.connect(self.on_publish_in_current_task_changed)
        self.task_combo.currentTextChanged.connect(self.on_task_selection_changed)
        self.target_version_combo.currentTextChanged.connect(self.on_target_version_changed)
        self.texture_renaming_cb.stateChanged.connect(self.on_texture_renaming_changed)
        self.select_all_button.clicked.connect(self.select_all_textures)
        self.clear_selection_button.clicked.connect(self.clear_texture_selection)
        self.select_new_textures_button.clicked.connect(self.select_new_textures)
        self.refresh_button.clicked.connect(self.refresh_textures)
        self.check_textures_button.clicked.connect(self.check_textures)
        self.cancel_button.clicked.connect(self.reject)
        self.publish_button.clicked.connect(self.publish_textures)
    
    def _populate_next_tasks_review(self):

for task in self.available_tasks:
            folders = task.get('folders', []) or []
            next_review = max([f.get("review") for f in folders if f.get('type') == "scene" and f.get("review") is not None and f.get("wip") is None], default=0)
            task["next_review"] = next_review + 1

current_file_folders = self.current_file_task.get('folders', []) or []
        next_review = max([f.get("review") for f in current_file_folders if f.get('type') == "scene" and f.get("review") is not None and f.get("wip") is None], default=0)
        self.current_file_task["next_review"] = next_review + 1

def load_data(self):
        """
        Load scene data and available textures
        """
        # Get current scene file
        try:
            scene_path = cmds.file(query=True, sceneName=True)
            if not scene_path:
                self.show_message("Warning", "No Maya scene file is currently open.", "warning")
                return
                
            scene_filename = os.path.basename(scene_path)
            
            # Get tasks for current file
            self.current_file_task, self.current_file_folder, self.available_tasks, self.linked_entity_name = get_file_tasks(scene_filename)
            print("Current file folder:", self.current_file_folder)
            self._populate_next_tasks_review()
            self.populate_task_combo()
            
        except Exception as e:
            print(f"Error loading scene data: {e}")
            self.show_message("Error", f"Failed to load scene data: {str(e)}", "critical")
        
        # Load textures
        self.refresh_textures()
    
    def populate_task_combo(self):
        """
        Populate the task combo box with available tasks
        """
        self.task_combo.clear()
        
        if not self.available_tasks:
            self.task_combo.addItem("No tasks available")
            self.task_combo.setEnabled(False)
            return
        
        # Add tasks to combo box with complete task data as ItemData
        current_task_index = 0
        for i, task in enumerate(self.available_tasks):
            task_name = task.get('maintask', {}).get('name', 'Unknown Task')
            self.task_combo.addItem(task_name, task)  # Store complete task data as ItemData
            
            # Set current file's task as default selection
            if (self.current_file_task and 
                task.get('key') == self.current_file_task.get('key')):
                current_task_index = i
        
        self.task_combo.setCurrentIndex(current_task_index)
    
    def get_selected_task(self):
        """
        Get the currently selected task data from combo box
        
        Returns:
            dict: Complete task data or None if no selection
        """
        return self.task_combo.currentData()
    
    def on_publish_in_current_task_changed(self):
        """
        Handle publish in current task checkbox change
        """
        use_current_task = self.publish_in_current_task_cb.isChecked()
        
        # Enable/disable task combo based on checkbox state
        self.task_combo.setEnabled(not use_current_task)
        
        if use_current_task and self.current_file_task:
            # Set task combo to current file task and update names
            current_task_key = self.current_file_task.get('key')
            for i in range(self.task_combo.count()):
                task_data = self.task_combo.itemData(i)
                if task_data and task_data.get('key') == current_task_key:
                    self.task_combo.setCurrentIndex(i)
                    break
        
        # Update texture names if renaming is enabled and textures exist
        if self.scene_textures and self.texture_renaming_cb.isChecked():
            self.update_texture_new_names()
            
            # Update New Name column in table
            for row, texture in enumerate(self.scene_textures):
                new_name = texture.get('new_name', texture['name'])
                new_name_item = QTableWidgetItem(new_name)
                new_name_item.setFlags(new_name_item.flags() & ~Qt.ItemIsEditable)
                self.texture_table.setItem(row, 3, new_name_item)
            
            # Reset texture check state since names may have changed
            self.texture_check_performed = False
            self.select_new_textures_button.setEnabled(False)
            self._update_publish_button_state(False)
            
            # Reset status column
            for row in range(self.texture_table.rowCount()):
                status_item = QTableWidgetItem("Not checked")
                status_item.setFlags(status_item.flags() & ~Qt.ItemIsEditable)
                status_item.setToolTip("Click 'Check Textures' to verify platform status")
                self.texture_table.setItem(row, 1, status_item)
    
    def get_effective_task(self):
        """
        Get the task to use for publishing operations (current file task or selected task)
        
        Returns:
            dict: Task data to use for publishing
        """
        if self.publish_in_current_task_cb.isChecked():
            return self.current_file_task
        else:
            return self.get_selected_task()
    
    def refresh_textures(self):
        """
        Refresh the texture table with current scene textures
        """
        # Get scene textures
        self.scene_textures = get_scene_textures()
        
        # Generate new texture names
        self.update_texture_new_names()
        
        # Clear and populate table
        self.texture_table.setRowCount(len(self.scene_textures))
        
        for row, texture in enumerate(self.scene_textures):
            # Publish checkbox (column 0) - checked by default for existing files
            checkbox = QCheckBox()
            checkbox.setChecked(texture['exists'])  # Only check if file exists
            self.texture_table.setCellWidget(row, 0, checkbox)
            
            # Status column (column 1) - initially empty until check is performed
            status_item = QTableWidgetItem("Not checked")
            status_item.setFlags(status_item.flags() & ~Qt.ItemIsEditable)
            status_item.setToolTip("Click 'Check Textures' to verify platform status")
            self.texture_table.setItem(row, 1, status_item)
            
            # Texture name (column 2)
            name_item = QTableWidgetItem(texture['name'])
            name_item.setFlags(name_item.flags() & ~Qt.ItemIsEditable)
            self.texture_table.setItem(row, 2, name_item)
            
            # New name (column 3)
            new_name = texture.get('new_name', texture['name'])
            new_name_item = QTableWidgetItem(new_name)
            new_name_item.setFlags(new_name_item.flags() & ~Qt.ItemIsEditable)
            self.texture_table.setItem(row, 3, new_name_item)
            
            # File path (column 4)
            path_item = QTableWidgetItem(texture['path'])
            path_item.setFlags(path_item.flags() & ~Qt.ItemIsEditable)
            if not texture['exists']:
                path_item.setForeground(Qt.red)  # Red text for missing files
            self.texture_table.setItem(row, 4, path_item)
            
            # Materials (column 5)
            materials_item = QTableWidgetItem(texture['usage'])
            materials_item.setFlags(materials_item.flags() & ~Qt.ItemIsEditable)
            self.texture_table.setItem(row, 5, materials_item)
        
        # Reset texture check state when refreshing
        self.texture_check_performed = False
        self.select_new_textures_button.setEnabled(False)
        
        # Update button states
        self.on_task_selection_changed()
    
    def update_texture_new_names(self):
        """
        Update the new names for textures based on renaming checkbox state and selected task
        """
        if self.texture_renaming_cb.isChecked():
            # Get task code from selected task
            task = self.get_selected_task()
            task_code = task.get('code') if task else None
            if task_code:
                # Generate new names using task code
                if self.target_version_combo.currentText() == "review":  # Review naming
                    name_mapping = generate_texture_new_names(self.scene_textures, task_code, review=task.get("next_review"))
                elif self.target_version_combo.currentText() == "current":
                    name_mapping = generate_texture_new_names(
                        self.scene_textures, task_code, 
                        review=self.current_file_folder.get("review"),
                        wip=self.current_file_folder.get("wip")
                    )
                else:  # Publish generic version naming
                    name_mapping = generate_texture_new_names(self.scene_textures, task_code)
                
                # Update texture objects with new names
                for texture in self.scene_textures:
                    texture['new_name'] = name_mapping.get(texture['path'], texture['name'])
            else:
                # No task code available, use original names
                for texture in self.scene_textures:
                    texture['new_name'] = texture['name']
        else:
            # Renaming disabled, use original names
            for texture in self.scene_textures:
                texture['new_name'] = texture['name']
    
    def on_texture_renaming_changed(self):
        """
        Handle texture renaming checkbox change
        """
        print("Texture renaming checkbox changed")
        # Update new names and refresh the table display
        if self.scene_textures:
            self.update_texture_new_names()
            
            # Update only the New Name column instead of full refresh
            for row, texture in enumerate(self.scene_textures):
                new_name = texture.get('new_name', texture['name'])
                new_name_item = QTableWidgetItem(new_name)
                new_name_item.setFlags(new_name_item.flags() & ~Qt.ItemIsEditable)
                self.texture_table.setItem(row, 3, new_name_item)  # New name is now column 3
            
            # Reset texture check state since names have changed
            self.texture_check_performed = False
            self.select_new_textures_button.setEnabled(False)
            self._update_publish_button_state(False)
            
            # Reset status column to "Not checked"
            for row in range(self.texture_table.rowCount()):
                status_item = QTableWidgetItem("Not checked")
                status_item.setFlags(status_item.flags() & ~Qt.ItemIsEditable)
                status_item.setToolTip("Click 'Check Textures' to verify platform status")
                self.texture_table.setItem(row, 1, status_item)  # Status column is now index 1
    
    def select_all_textures(self):
        """
        Select all textures for publishing
        """
        for row in range(self.texture_table.rowCount()):
            checkbox = self.texture_table.cellWidget(row, 0)  # Publish checkbox is now column 0
            if checkbox and self.scene_textures[row]['exists']:  # Only check existing files
                checkbox.setChecked(True)
    
    def clear_texture_selection(self):
        """
        Clear all texture selections
        """
        for row in range(self.texture_table.rowCount()):
            checkbox = self.texture_table.cellWidget(row, 0)  # Publish checkbox is now column 0
            if checkbox:
                checkbox.setChecked(False)
        self.update_publish_button()

def update_publish_button(self):
        """
        Update the state of the publish button based on texture selection
        """
        has_tasks = self.task_combo.count() > 0
        has_textures = len(self.scene_textures) > 0
        # Only enable publish button if textures have been checked
        self._update_publish_button_state(has_tasks and has_textures and self.texture_check_performed)

def _refresh_textures_new_names(self):
        has_tasks = self.task_combo.count() > 0
        has_textures = len(self.scene_textures) > 0
        # Update texture names when task selection changes (if textures exist and renaming is enabled)
        if has_textures and self.texture_renaming_cb.isChecked():
            # Update texture names based on new task selection
            self.update_texture_new_names()
            
            # Update only the New Name column in the table
            for row, texture in enumerate(self.scene_textures):
                new_name = texture.get('new_name', texture['name'])
                new_name_item = QTableWidgetItem(new_name)
                new_name_item.setFlags(new_name_item.flags() & ~Qt.ItemIsEditable)
                self.texture_table.setItem(row, 3, new_name_item)  # New name is column 3
            
            # Reset texture check state since names may have changed
            self.texture_check_performed = False
            self.select_new_textures_button.setEnabled(False)
            
            # Reset status column to "Not checked"
            for row in range(self.texture_table.rowCount()):
                status_item = QTableWidgetItem("Not checked")
                status_item.setFlags(status_item.flags() & ~Qt.ItemIsEditable)
                status_item.setToolTip("Click 'Check Textures' to verify platform status")
                self.texture_table.setItem(row, 1, status_item)  # Status column is index 1
        
        # Only enable publish button if textures have been checked
        self._update_publish_button_state(has_tasks and has_textures and self.texture_check_performed)

def on_task_selection_changed(self):
        """
        Handle task selection change - updates texture names in real-time
        """
        self._refresh_textures_new_names()

def on_target_version_changed(self):
        """
        Handle target version change
        """
        self._refresh_textures_new_names()

def check_textures(self):
        """
        Check if textures already exist in the platform
        """
        if not self.scene_textures:
            self.show_message("Warning", "No textures found in the scene.", "warning")
            return
        
        try:
            # Disable check button while processing
            self.check_textures_button.setEnabled(False)
            self.check_textures_button.setText("Checking...")
            QApplication.processEvents()
            
            # Get list of texture names to check
            texture_names = []
            for texture in self.scene_textures:
                # Use new name if texture renaming is enabled, otherwise original name
                texture_name = texture['name']
                texture_names.append(texture_name)
            
            # Query the platform using get_files function
            platform_response = get_files(texture_names)
            print(f"Response: {platform_response}")
            # Update texture status based on response
            for texture in self.scene_textures:
                texture_name = texture['name']
                # Convert filename to key format (dots replaced with underscores)
                filename_key = texture_name.replace(".", "_")
                
                if platform_response and platform_response.get(filename_key) is not None:
                    # Texture exists in platform
                    texture['publish_status'] = 'exists'
                else:
                    # Texture is new (doesn't exist in platform)
                    texture['publish_status'] = 'new'
            
            # Update table display with status colors
            self.update_texture_status_display()
            
            # Mark check as performed and enable relevant buttons
            self.texture_check_performed = True
            self.select_new_textures_button.setEnabled(True)
            
            # Update publish button state
            self.update_publish_button()
            
        except Exception as e:
            error_msg = f"Error checking textures: {str(e)}"
            self.show_message("Error", error_msg, "critical")
            print(error_msg)
            
        finally:
            # Re-enable check button
            self.check_textures_button.setEnabled(True)
            self.check_textures_button.setText("Check Textures")
    
    def update_texture_status_display(self):
        """
        Update the texture table with status color indicators
        """
        for row, texture in enumerate(self.scene_textures):
            status = texture.get('publish_status', 'unknown')
            
            # Create status item with appropriate color
            status_item = QTableWidgetItem()
            if status == 'new':
                status_item.setBackground(QColor(144, 238, 144))  # Light green
                status_item.setText("New")
                status_item.setToolTip("Texture is new and can be published")
            elif status == 'exists':
                status_item.setBackground(QColor(255, 165, 0))   # Orange
                status_item.setText("Exists")
                status_item.setToolTip("Texture already exists in platform - will override if published")
            else:
                status_item.setText("Unknown")
                status_item.setToolTip("Texture status unknown - check failed")
            
            status_item.setFlags(status_item.flags() & ~Qt.ItemIsEditable)
            self.texture_table.setItem(row, 1, status_item)  # Status column is now index 1
    
    def select_new_textures(self):
        """
        Select only textures that are new (don't exist in platform)
        """
        if not self.texture_check_performed:
            self.show_message("Warning", "Please check textures first before selecting new ones.", "warning")
            return
        
        for row, texture in enumerate(self.scene_textures):
            checkbox = self.texture_table.cellWidget(row, 0)  # Publish checkbox is now column 0
            if checkbox:
                status = texture.get('publish_status', 'unknown')
                # Only check textures that are new and exist on disk
                checkbox.setChecked(status == 'new' and texture['exists'])
    
    def get_selected_textures(self):
        """
        Get list of selected textures for publishing
        
        Returns:
            list: Selected texture dictionaries
        """
        selected = []
        for row in range(self.texture_table.rowCount()):
            checkbox = self.texture_table.cellWidget(row, 0)  # Publish checkbox is now column 0
            if checkbox and checkbox.isChecked():
                selected.append(self.scene_textures[row])
        return selected
    
    def show_message(self, title, message, message_type="information"):
        """
        Show a message dialog
        """
        msg_box = QMessageBox(self)
        msg_box.setWindowTitle(title)
        msg_box.setText(message)
        
        if message_type == "warning":
            msg_box.setIcon(QMessageBox.Warning)
        elif message_type == "critical":
            msg_box.setIcon(QMessageBox.Critical)
        else:
            msg_box.setIcon(QMessageBox.Information)
        
        msg_box.exec_()
    
    def publish_textures(self):
        """
        Publish selected textures to the platform
        """
        # Get selected textures
        selected_textures = self.get_selected_textures()
        
        if not selected_textures:
            self.show_message("Warning", "No textures selected for publishing.", "warning")
            return
        
        # Check if any selected textures already exist and show confirmation dialog
        existing_textures = []
        for texture in selected_textures:
            if texture.get('publish_status') == 'exists':
                texture_name = texture.get('new_name', texture['name'])
                existing_textures.append(texture_name)
        
        if existing_textures:
            # Show confirmation dialog for overriding existing textures
            existing_list = "\n".join([f"• {name}" for name in existing_textures[:10]])  # Limit to 10
            if len(existing_textures) > 10:
                existing_list += f"\n• ... and {len(existing_textures) - 10} more"
           
            confirmation_msg = (f"You have {len(existing_textures)} texture(s) selected that already exist in the platform:\n\n"
                              f"{existing_list}\n\n"
                              f"Are you sure you want to override them?")
            
            reply = QMessageBox.question(self, "Override Existing Textures", confirmation_msg,
                                       QMessageBox.Yes | QMessageBox.No, QMessageBox.No)
            if reply != QMessageBox.Yes:
                return  # User cancelled
        
        # Get effective task (current file task or selected task)
        selected_task = self.get_effective_task()
        if not selected_task:
            self.show_message("Error", "No task available for publishing.", "critical")
            return
        
        try:
            # Show progress bar and disable UI during publishing
            self.show_progress_bar(True)
            self.publish_button.setEnabled(False)
            self.publish_button.setToolTip("Publishing in progress...")
            self.publish_button.setText("Publishing...")
            
            # Calculate total steps for progress
            total_textures = len(selected_textures)
            
            # Handle target version and folder selection
            target_version = self.target_version_combo.currentText()
            target_folder = self.target_folder_combo.currentText()
            
            # Step 1: Get base folder based on version selection (5% progress)
            if target_version == "current":
                self.update_progress(5, "Using current file folder...")
                if not self.current_file_folder or not self.current_file_folder.get('key'):
                    self.show_message("Error", "Current file has no associated folder.", "critical")
                    return
                base_folder_key = self.current_file_folder.get('key')
            elif target_version == "review":
                self.update_progress(5, "Creating task review folder...")
                QApplication.processEvents()
                # Create new review folder for selected task
                review_result = create_task_review_folder(selected_task['key'])
                if not review_result or not review_result.get('folder'):
                    self.show_message("Error", "Failed to create task review folder.", "critical")
                    return
                base_folder_key = review_result['folder']['key']
            else:  # target_version == "publish"
                self.update_progress(5, "Using task publish folder...")
                QApplication.processEvents()
                # Get publish folder key
                publish_folder_key = selected_task.get('publishFolder', {}).get('key')
                if not publish_folder_key:
                    self.show_message("Error", "Selected task has no publish folder.", "critical")
                    return
                base_folder_key = publish_folder_key
            
            # Step 2: Handle target folder within the chosen version folder
            if target_folder == "scene":
                # Use base folder directly
                folder_key = base_folder_key
            else:  # target_folder == "textures"
                # Create textures subfolder in base folder
                self.update_progress(8, "Creating textures subfolder...")
                QApplication.processEvents()
                self.output_folder = create_output_folder(base_folder_key, 'textures')
                if not self.output_folder:
                    self.show_message("Error", "Failed to create textures folder in the platform.", "critical")
                    return
                folder_key = self.output_folder['folder']['key']
            
            # Track published textures for path updating
            texture_mappings = []
            published_files = []
            failed_files = []
            
            # Process each selected texture
            for current_index, texture in enumerate(selected_textures, 1):
                try:
                    original_name = texture['name']
                    texture_path = texture['path']
                    texture_nodes = texture['nodes']
                    new_name = texture.get('new_name', original_name)  # Use new name if available
                    
                    # Update progress (5% + 90% distributed across textures)
                    texture_progress = int(5 + (current_index / total_textures) * 90)
                    progress_text = f"Processing: {new_name} ({current_index}/{total_textures})"
                    self.update_progress(texture_progress, progress_text)
                    QApplication.processEvents()
                    
                    print(f"Publishing texture: {original_name} -> {new_name}")
                    
                    # Create file entry in database using new name
                    file_data = create_file(new_name, folder_key)
                    if not file_data:
                        failed_files.append(f"Failed to create database entry for '{new_name}'")
                        continue
                    
                    # Get file local path from database response
                    file_local_path = file_data['file']['fileLocal']
                    upload_link = file_data['file']['uploadLink']
                    file_key = file_data['file']['key']
                    
                    # Determine the actual local file path with new name
                    local_dir = os.path.dirname(file_local_path)
                    actual_local_path = os.path.join(local_dir, new_name)
                    
                    # Check if copy is needed or if source equals destination
                    needs_copy, file_to_upload, reason = should_copy_file(texture_path, actual_local_path)
                    
                    # Update progress message to show copy status
                    if not needs_copy:
                        updated_progress_text = f"Processing: {new_name} ({current_index}/{total_textures}) - {reason}"
                        self.update_progress(texture_progress, updated_progress_text)
                        QApplication.processEvents()
                    
                    if needs_copy:
                        # Copy texture file to actual local location with new name
                        if not copy_texture_file(texture_path, actual_local_path):
                            failed_files.append(f"Failed to copy '{original_name}' to local storage")
                            continue
                        print(f"Copied texture for publishing: {original_name} -> {new_name}")
                    else:
                        print(f"Skipping copy - {reason}: {original_name}")
                    
                    # Upload file to platform (use appropriate file path)
                    upload_result = upload_file_to_platform(
                        file_to_upload,  # Upload from either copied file or original file
                        upload_link,
                        file_key=file_key,
                        ghost_file=not self.upload_files_cb.isChecked()
                    )
                    
                    if upload_result:
                        published_files.append(new_name)
                        
                        # Store mapping for path update (handle multiple nodes)
                        texture_mappings.append({
                            'nodes': texture_nodes,  # List of nodes using this texture
                            'new_path': file_to_upload  # Use the actual file path that was uploaded
                        })
                        
                        print(f"Successfully published texture: {original_name} -> {new_name}")
                    else:
                        failed_files.append(f"Failed to upload '{new_name}' to platform")
                        
                except Exception as e:
                    error_msg = f"Error publishing '{texture.get('name', 'unknown')}': {str(e)}"
                    failed_files.append(error_msg)
                    print(error_msg)
            
            # Update texture paths in Maya if requested (95-100% progress)
            updated_paths_count = 0
            if self.update_paths_cb.isChecked() and texture_mappings:
                try:
                    self.update_progress(95, "Updating Maya texture paths...")
                    QApplication.processEvents()
                    updated_paths_count = update_texture_paths_multiple_nodes(texture_mappings)
                except Exception as e:
                    print(f"Error updating texture paths: {e}")
            
            # Final progress update
            self.update_progress(100, "Publishing completed!")
            QApplication.processEvents()
            
            # Show results
            self.show_publishing_results(published_files, failed_files, updated_paths_count)
            
        except Exception as e:
            error_msg = f"An error occurred during publishing: {str(e)}"
            self.show_message("Error", error_msg, "critical")
            print(error_msg)
            
        finally:
            # Hide progress bar and re-enable UI
            self.show_progress_bar(False)
            self._update_publish_button_state(True)
            self.publish_button.setText("Publish Textures")
    
    def show_publishing_results(self, published_files, failed_files, updated_paths_count):
        """
        Show publishing results to user
        
        Args:
            published_files (list): List of successfully published texture names
            failed_files (list): List of error messages for failed files
            updated_paths_count (int): Number of texture paths updated in Maya
        """
        if published_files and not failed_files:
            # All successful
            message = f"Successfully published {len(published_files)} texture(s):\n"
            message += "\n".join([f"• {name}" for name in published_files])
            
            if updated_paths_count > 0:
                message += f"\n\nUpdated {updated_paths_count} texture path(s) in Maya scene."
            
            self.show_message("Success", message)
            self.accept()  # Close dialog on complete success
            
        elif published_files and failed_files:
            # Partial success
            message = f"Published {len(published_files)} texture(s) successfully:\n"
            message += "\n".join([f"• {name}" for name in published_files])
            message += f"\n\n{len(failed_files)} texture(s) failed:\n"
            message += "\n".join([f"• {error}" for error in failed_files[:5]])  # Limit to 5 errors
            
            if len(failed_files) > 5:
                message += f"\n• ... and {len(failed_files) - 5} more errors"
            
            if updated_paths_count > 0:
                message += f"\n\nUpdated {updated_paths_count} texture path(s) in Maya scene."
            
            self.show_message("Partial Success", message, "warning")
            
        else:
            # All failed
            message = "Failed to publish any textures:\n"
            message += "\n".join([f"• {error}" for error in failed_files[:10]])  # Limit to 10 errors
            
            if len(failed_files) > 10:
                message += f"\n• ... and {len(failed_files) - 10} more errors"
            
            self.show_message("Error", message, "critical")
    
    def show_progress_bar(self, visible):
        """
        Show or hide the progress bar and label
        
        Args:
            visible (bool): Whether to show the progress widgets
        """
        self.progress_bar.setVisible(visible)
        self.progress_label.setVisible(visible)
        
        if not visible:
            # Reset progress when hiding
            self.progress_bar.setValue(0)
            self.progress_label.setText("Ready to publish...")
    
    def update_progress(self, percentage, message):
        """
        Update progress bar value and label text
        
        Args:
            percentage (int): Progress percentage (0-100)
            message (str): Status message to display
        """
        self.progress_bar.setValue(percentage)
        self.progress_label.setText(message)
    
    def reject(self):
        """
        Override reject to close the dialog
        """
        super(TexturePublisherDialog, self).reject()

# Global variable to track dialog instance
_texture_publisher_dialog = None

def show_texture_publisher_dialog():
    """
    Main function to show the texture publisher dialog
    Prevents multiple instances from being opened simultaneously
    
    Returns:
        TexturePublisherDialog: The dialog instance or None if already open
    """
    global _texture_publisher_dialog
    
    # Check if dialog already exists and is visible
    if _texture_publisher_dialog is not None:
        # Check if the dialog still exists and is visible
        try:
            if _texture_publisher_dialog.isVisible():
                # Dialog is already open, bring it to front
                _texture_publisher_dialog.raise_()
                _texture_publisher_dialog.activateWindow()
                print("Texture Publisher dialog is already open. Bringing to front.")
                return _texture_publisher_dialog
        except RuntimeError:
            # Dialog was deleted, reset the reference
            _texture_publisher_dialog = None
    
    # Create new dialog instance
    _texture_publisher_dialog = TexturePublisherDialog()
    
    # Connect to cleanup when dialog is closed
    def cleanup_dialog():
        global _texture_publisher_dialog
        _texture_publisher_dialog = None
    
    _texture_publisher_dialog.finished.connect(cleanup_dialog)
    _texture_publisher_dialog.show()
    
    return _texture_publisher_dialog

# Show the dialog
show_texture_publisher_dialog()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go