code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Anim Publisher

Jorge Hernandez Ibañez 22/08/2025

Tags

Anim Publisher

Jorge Herna…

Action v2

22/08/2025

Maya

Pseudo-Code

Parameters

Talk with TD Support

Import to my Pipeline

Code

import maya.cmds as cmds
import maya.OpenMayaUI as omui
import os
import requests
import json

# Try to import PySide6 first, fallback to PySide2
try:
    from PySide6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, QPushButton, QFormLayout, QMessageBox, QCheckBox, QListWidget, QSpinBox
    from PySide6.QtCore import Qt
    from shiboken6 import wrapInstance
    PYSIDE_VERSION = 6
except ImportError:
    try:
        from PySide2.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, QPushButton, QFormLayout, QMessageBox, QCheckBox, QListWidget, QSpinBox
        from PySide2.QtCore import Qt
        from shiboken2 import wrapInstance
        PYSIDE_VERSION = 2
    except ImportError:
        raise ImportError("Neither PySide6 nor PySide2 is available")

# Import your pipeline module (assuming it exists)
try:
    import pipelinepro as pipeline
except ImportError:
    print("Warning: pipeline module not found. Some functionality may not work.")
    pipeline = None

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_data():
    """
    Get scene data from the pipeline database
    Same function as in the Nuke script but adapted for Maya
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    query = """
        query {
        file(fileName: "{filename}", token:"{token}"){
          fileName
          uploadLink
          folder{
            key
            code
            relTaskFolder{
              name
              code
            }
          }
        }
      }
    """
    
    # Get current Maya scene file
    filepath = cmds.file(query=True, sceneName=True)
    if not filepath:
        print("No scene file is currently open")
        return None
        
    filename = os.path.basename(filepath)
    query = query.replace("{filename}", filename)
    
    try:
        response = pipeline.query(query)
    except Exception as e:
        print("Error on DB query: ", e)
        return None
        
    print(response)
    file_props = response["file"]
    if not file_props:
        print(f"No data found for file {filename}.")
        return None
        
    return file_props

def create_output_folder(src_folder_key, folder_name='cache'):
    """
    Create output folder in the pipeline system
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    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 = pipeline.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
    """
    if not pipeline:
        print("Pipeline module not available")
        return None
        
    mutation = '''
    mutation{
      newFile(token:"{token}", fileName:"{fileName}", folderKey:"{folderKey}"){
        file{
          fileName
          key
          uploadLink
        }
      }
    }
    '''
    mutation = mutation.replace("{fileName}", filename)
    mutation = mutation.replace("{folderKey}", folder_key)
    
    try:
        response = pipeline.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 pipeline.query(mutation)

def upload_file_to_platform(filepath, upload_link, file_key=None):
    """
    Upload file to the platform and mark as completed
    """
    filename = os.path.basename(filepath)
    
    if not file_key:
        print("No file key provided")
        return None
        
    try:
        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)))
        mutation = mutation.replace("{pathToFile}", os.path.normpath(filepath).replace("\\", "/"))
        mutation = mutation.replace("{fileKey}", file_key)
        
        response = pipeline.query(mutation)
        print(f"File '{filename}' published successfully.")
        return response['completedFile']
        
    except Exception as e:
        print(f"Error uploading file: {e}")
        return None

def get_asset_metadata(group_node):
    """
    Retrieves pipeline metadata from a Maya group node.
    """
    try:
        if not cmds.objExists(group_node):
            print(f"Group node does not exist: {group_node}")
            return {}
        
        metadata = {}
        pipelinepro_attrs = [
            "pipelinepro_file_key", "pipelinepro_technical_name", "pipelinepro_original_path",
            "pipelinepro_asset_type", "pipelinepro_import_date", "pipelinepro_review", 
            "pipelinepro_wip", "pipelinepro_namespace_index", "pipelinepro_is_shot"
        ]
        
        for attr in pipelinepro_attrs:
            if cmds.attributeQuery(attr, node=group_node, exists=True):
                try:
                    value = cmds.getAttr(f"{group_node}.{attr}")
                    metadata[attr] = value
                except:
                    pass
        
        return metadata
        
    except Exception as e:
        print(f"Error getting metadata from group node '{group_node}': {e}")
        return {}

def get_namespace_from_group(group_name):
    """
    Extract namespace from group metadata or group name structure
    
    Args:
        group_name (str): Name of the group (e.g., "PR|TVFX_PR_0003_cube_01_grp")
        
    Returns:
        str: Namespace extracted from group metadata or parsed from name
    """
    try:
        parts = group_name.split("|")
        namespace_part = parts[-1].replace("_grp", "")
        return namespace_part
    except Exception as e:
        print(f"Error extracting namespace from group '{group_name}': {e}")
        return group_name.replace("_grp", "").replace("|", "_")

def get_scene_frame_range():
    """
    Get the current Maya playback frame range
    
    Returns:
        tuple: (start_frame, end_frame) from Maya's playback options
    """
    try:
        start_frame = int(cmds.playbackOptions(query=True, minTime=True))
        end_frame = int(cmds.playbackOptions(query=True, maxTime=True))
        return start_frame, end_frame
    except Exception as e:
        print(f"Error getting scene frame range: {e}")
        return 1, 100  # Default fallback

def export_animation_alembic(group_name, output_path, start_frame=None, end_frame=None):
    """
    Export animation group to Alembic format
    
    Args:
        group_name (str): Name of the group to export
        output_path (str): Full path where to save the ABC file
        start_frame (int, optional): Start frame for export. If None, uses Maya's playback range
        end_frame (int, optional): End frame for export. If None, uses Maya's playback range
    """
    try:
        # Select the group
        cmds.select(group_name, replace=True)
        
        # Load AbcExport plugin if not already loaded
        if not cmds.pluginInfo('AbcExport', query=True, loaded=True):
            cmds.loadPlugin('AbcExport')
        
        # Get animation range - use provided frames or fall back to Maya's playback range
        if start_frame is None or end_frame is None:
            scene_start, scene_end = get_scene_frame_range()
            if start_frame is None:
                start_frame = scene_start
            if end_frame is None:
                end_frame = scene_end
        start_frame = float(start_frame)
        end_frame = float(end_frame)
        # Build AbcExport command with enhanced material and face set support
        # Enhanced parameters for complete material and face set export
        print(f"Animation Frame Range exported: {start_frame} to {end_frame}")
        abc_export_cmd = (
            f'-frameRange {start_frame} {end_frame} '
            f'-uvWrite -writeUVSets '           # UV data
            f'-writeFaceSets -writeMaterials '  # Face sets with material assignments
            f'-writeColorSets -writeCreases '   # Color sets and subdivision creases
            f'-worldSpace -writeVisibility '    # World space transforms and visibility
            f'-eulerFilter -autoSubd '          # Animation filtering and auto subdivision
            f'-wholeFrameGeo -stripNamespaces ' # Full geometry per frame and clean naming
            f'-dataFormat ogawa '               # Efficient binary format
            f'-root {group_name} '
            f'-file "{output_path}"'
        )
        
        # Execute the export using Python API (more reliable than MEL)
        cmds.AbcExport(jobArg=abc_export_cmd)
        
        print(f"Animation group '{group_name}' exported successfully to: {output_path}")
        return True
        
    except Exception as e:
        print(f"Error exporting animation group '{group_name}': {e}")
        return False

def get_available_animation_groups():
    """
    Get all available animation groups with asset structure
    
    Returns:
        list: List of group names available for publishing that match the pattern
    """
    groups = []
    
    # Get all transform nodes in the scene
    all_transforms = cmds.ls(type='transform', l=True) or []
    
    for transform in all_transforms:
        # Check if this matches the expected pattern: {assetType}|{namespace}_grp
        if "|" in transform and transform.endswith("_grp"):
            # Verify it has pipeline metadata (indicating it's an imported asset)
            metadata = get_asset_metadata(transform)
            if metadata.get("pipelinepro_technical_name"):
                groups.append(transform)
    
    return groups

def get_task_name_from_scene_data(scene_data):
    """
    Extract task name from scene data for file naming
    
    Args:
        scene_data (dict): Scene data containing task folder information
        
    Returns:
        str: Task name for use in file naming
    """
    try:
        task_folder = scene_data.get('folder', {}).get('relTaskFolder', [{}])[0]
        task_name = task_folder.get('name', 'unknown_task')
        return task_name
    except Exception as e:
        print(f"Error extracting task name from scene data: {e}")
        return "unknown_task"

def extract_asset_type_from_name(group_name):
    """
    Extract asset type from group name
    Expected format: {assetType}|{namespace}_grp
    
    Args:
        group_name (str): Name of the group
        
    Returns:
        str: Asset type extracted from the name
    """
    if "|" in group_name:
        # Split by pipe and take the first part as asset type
        parts = group_name.split("|")
        return parts[0]
    else:
        # If no pipe, try to extract from metadata
        metadata = get_asset_metadata(group_name)
        return metadata.get("pipelinepro_asset_type", "Unknown")

class AnimationPublisherDialog(QDialog):
    """
    Dialog for publishing animations from Maya to the pipeline platform
    """
    
    def __init__(self, parent=maya_main_window()):
        super(AnimationPublisherDialog, self).__init__(parent)
        
        # Initialize UI
        self.setWindowTitle("Animation Publisher")
        self.setMinimumSize(450, 350)
        self.setMaximumSize(600, 450)
        
        # Store scene data
        self.scene_data = None
        self.output_folder = None
        
        self.create_widgets()
        self.create_layout()
        self.create_connections()
        
        # Load available groups and scene data
        self.load_data()
    
    def create_widgets(self):
        """
        Create all UI widgets
        """
        # Export options at the top
        self.options_label = QLabel("Export Options:")
        self.selected_groups_cb = QCheckBox("Export Selected Groups")
        self.selected_groups_cb.setEnabled(True)
        self.selected_groups_cb.setChecked(False)
        self.selected_groups_cb.setToolTip("Export multiple selected groups instead of single group")
        
        # Single group selection
        self.group_label = QLabel("Select Animation Group:")
        self.group_combo = QComboBox()
        self.group_combo.setToolTip("Select an animation group to publish")
        
        # Multiple group selection (initially hidden)
        self.groups_list_label = QLabel("Groups to Export:")
        self.groups_list_widget = QListWidget()
        self.groups_list_widget.setMaximumHeight(120)
        self.groups_list_widget.setToolTip("List of groups that will be exported")
        self.groups_list_widget.hide()
        self.groups_list_label.hide()
        
        self.info_label = QLabel("Scene Information:")
        self.scene_info_label = QLabel("Loading scene data...")
        self.scene_info_label.setWordWrap(True)
        
        self.export_format_label = QLabel("Export Format:")
        self.export_format_info = QLabel("ABC (Alembic)")
        self.export_format_info.setStyleSheet("font-weight: bold;")
        
        # Frame range controls
        self.custom_frame_range_cb = QCheckBox("Custom Animation Frame Range")
        self.custom_frame_range_cb.setToolTip("Override default playback range for animation export")
        
        self.start_frame_label = QLabel("Start Frame:")
        self.start_frame_spinbox = QSpinBox()
        self.start_frame_spinbox.setRange(-9999, 9999)
        self.start_frame_spinbox.setToolTip("First frame to export")
        
        self.end_frame_label = QLabel("End Frame:")
        self.end_frame_spinbox = QSpinBox()
        self.end_frame_spinbox.setRange(-9999, 9999)
        self.end_frame_spinbox.setToolTip("Last frame to export")
        
        # Initialize with scene frame range
        scene_start, scene_end = get_scene_frame_range()
        self.start_frame_spinbox.setValue(scene_start)
        self.end_frame_spinbox.setValue(scene_end)
        
        # Initially disable frame range controls
        self.start_frame_spinbox.setEnabled(False)
        self.end_frame_spinbox.setEnabled(False)
        
        # Buttons
        self.publish_button = QPushButton("Publish Animation")
        self.refresh_button = QPushButton("Refresh Groups")
        self.cancel_button = QPushButton("Cancel")
        
        # Initially disable publish button
        self.publish_button.setEnabled(False)
    
    def create_layout(self):
        """
        Create and set the layout for the dialog
        """
        # Main layout
        main_layout = QVBoxLayout(self)
        
        # Export options at the top
        options_layout = QVBoxLayout()
        options_layout.addWidget(self.options_label)
        options_layout.addWidget(self.selected_groups_cb)
        
        # Group selection layout (single or multiple)
        group_selection_layout = QVBoxLayout()
        # Single group selection
        single_group_layout = QFormLayout()
        single_group_layout.addRow(self.group_label, self.group_combo)
        group_selection_layout.addLayout(single_group_layout)
        
        # Multiple group selection (list widget)
        group_selection_layout.addWidget(self.groups_list_label)
        group_selection_layout.addWidget(self.groups_list_widget)
        
        # Export format info
        format_layout = QFormLayout()
        format_layout.addRow(self.export_format_label, self.export_format_info)
        
        # Frame range layout
        frame_range_layout = QVBoxLayout()
        frame_range_layout.addWidget(self.custom_frame_range_cb)
        
        # Frame range controls in horizontal layout
        frame_controls_layout = QHBoxLayout()
        frame_controls_layout.addWidget(self.start_frame_label)
        frame_controls_layout.addWidget(self.start_frame_spinbox)
        frame_controls_layout.addWidget(self.end_frame_label)
        frame_controls_layout.addWidget(self.end_frame_spinbox)
        frame_range_layout.addLayout(frame_controls_layout)
        
        # Scene info layout
        info_layout = QVBoxLayout()
        info_layout.addWidget(self.info_label)
        info_layout.addWidget(self.scene_info_label)
        
        # Button layout
        button_layout = QHBoxLayout()
        button_layout.addWidget(self.refresh_button)
        button_layout.addWidget(self.cancel_button)
        button_layout.addWidget(self.publish_button)
        
        # Add layouts to main layout
        main_layout.addLayout(options_layout)
        main_layout.addLayout(group_selection_layout)
        main_layout.addLayout(format_layout)
        main_layout.addLayout(frame_range_layout)
        main_layout.addLayout(info_layout)
        main_layout.addLayout(button_layout)
    
    def create_connections(self):
        """
        Connect signals to slots
        """
        self.publish_button.clicked.connect(self.publish_animation)
        self.refresh_button.clicked.connect(self.refresh_groups)
        self.cancel_button.clicked.connect(self.reject)
        self.group_combo.currentTextChanged.connect(self.on_group_selection_changed)
        self.selected_groups_cb.stateChanged.connect(self.on_export_mode_changed)
        self.custom_frame_range_cb.stateChanged.connect(self.on_frame_range_mode_changed)
        self.start_frame_spinbox.valueChanged.connect(self.validate_frame_range)
        self.end_frame_spinbox.valueChanged.connect(self.validate_frame_range)
    
    def load_data(self):
        """
        Load scene data and available groups
        """
        # Load scene data
        self.scene_data = get_scene_data()
        self.update_scene_info()
        
        # Load available groups
        self.refresh_groups()
    
    def update_scene_info(self):
        """
        Update the scene information display
        """
        if self.scene_data:
            folder_info = self.scene_data.get('folder', {})
            task_folder = folder_info.get('relTaskFolder', [{}])[0]
            
            info_text = f"File: {self.scene_data.get('fileName', 'Unknown')}\n"
            info_text += f"Task: {task_folder.get('name', 'Unknown')} ({task_folder.get('code', 'Unknown')})\n"
            info_text += f"Folder: {folder_info.get('code', 'Unknown')}"
            
            self.scene_info_label.setText(info_text)
            self.scene_info_label.setStyleSheet("color: green;")
        else:
            self.scene_info_label.setText("Failed to load scene data. Publishing may not work correctly.")
            self.scene_info_label.setStyleSheet("color: red;")
    
    def refresh_groups(self):
        """
        Refresh the list of available animation groups
        """
        # Clear existing items
        self.group_combo.clear()
        self.groups_list_widget.clear()
        
        # Get available groups
        groups = get_available_animation_groups()
        
        if groups:
            self.group_combo.addItems(groups)
            self.group_combo.setEnabled(True)
            
            # Populate list widget for multiple selection
            for group in groups:
                self.groups_list_widget.addItem(group)
        else:
            self.group_combo.addItem("No animation groups found")
            self.group_combo.setEnabled(False)
            self.groups_list_widget.addItem("No animation groups found")
        
        # Update UI based on current export mode
        self.on_export_mode_changed()
        
        # Update publish button state
        self.on_group_selection_changed()
    
    def on_export_mode_changed(self):
        """
        Handle export mode change (single vs multiple groups)
        """
        export_selected = self.selected_groups_cb.isChecked()
        
        if export_selected:
            # Multiple groups mode
            self.group_combo.setEnabled(False)
            self.groups_list_label.show()
            self.groups_list_widget.show()
        else:
            # Single group mode
            self.group_combo.setEnabled(True)
            self.groups_list_label.hide()
            self.groups_list_widget.hide()
        
        # Update publish button state
        self.on_group_selection_changed()
    
    def on_group_selection_changed(self):
        """
        Handle group selection change
        """
        has_scene_data = self.scene_data is not None
        
        if self.selected_groups_cb.isChecked():
            # Multiple groups mode - check if list has groups
            has_groups = self.groups_list_widget.count() > 0
            has_valid_groups = has_groups and self.groups_list_widget.item(0).text() != "No animation groups found"
        else:
            # Single group mode - check combo box
            has_groups = self.group_combo.count() > 0 and self.group_combo.isEnabled()
            has_valid_groups = has_groups and self.group_combo.currentText() != "No animation groups found"
        
        self.publish_button.setEnabled(has_valid_groups and has_scene_data)
    
    def on_frame_range_mode_changed(self):
        """
        Handle custom frame range checkbox change
        """
        custom_enabled = self.custom_frame_range_cb.isChecked()
        self.start_frame_spinbox.setEnabled(custom_enabled)
        self.end_frame_spinbox.setEnabled(custom_enabled)
        
        # If enabling custom range, reset to current scene values
        if custom_enabled:
            scene_start, scene_end = get_scene_frame_range()
            self.start_frame_spinbox.setValue(scene_start)
            self.end_frame_spinbox.setValue(scene_end)
    
    def validate_frame_range(self):
        """
        Validate that start frame is not greater than end frame
        """
        start_frame = self.start_frame_spinbox.value()
        end_frame = self.end_frame_spinbox.value()
        
        if start_frame > end_frame:
            # Auto-adjust end frame to be at least equal to start frame
            self.end_frame_spinbox.setValue(start_frame)
    
    def get_export_frame_range(self):
        """
        Get the frame range to use for export
        
        Returns:
            tuple: (start_frame, end_frame) or (None, None) if using scene default
        """
        if self.custom_frame_range_cb.isChecked():
            return self.start_frame_spinbox.value(), self.end_frame_spinbox.value()
        else:
            return None, None
    
    def show_message(self, title, message, message_type="information"):
        """
        Show a message dialog
        
        Args:
            title (str): Dialog title
            message (str): Message to display
            message_type (str): Type of message ("information", "warning", "critical")
        """
        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_animation(self):
        """
        Publish the selected animation(s) to the platform
        """
        if not self.scene_data:
            self.show_message("Error", "No scene data available. Cannot publish animation.", "critical")
            return
        
        # Get groups to export based on mode
        if self.selected_groups_cb.isChecked():
            # Multiple groups mode
            groups_to_export = []
            for i in range(self.groups_list_widget.count()):
                item_text = self.groups_list_widget.item(i).text()
                if item_text != "No animation groups found":
                    groups_to_export.append(item_text)
            
            if not groups_to_export:
                self.show_message("Error", "No animation groups available for publishing.", "critical")
                return
        else:
            # Single group mode
            if not self.group_combo.isEnabled():
                self.show_message("Error", "No animation groups available for publishing.", "critical")
                return
            
            selected_group = self.group_combo.currentText()
            if not selected_group or selected_group == "No animation groups found":
                self.show_message("Error", "Please select a valid animation group to publish.", "critical")
                return
            
            groups_to_export = [selected_group]
        
        try:
            # Disable the publish button to prevent multiple clicks
            self.publish_button.setEnabled(False)
            self.publish_button.setText("Publishing...")
            
            # Create output folder
            self.output_folder = create_output_folder(self.scene_data["folder"]["key"])
            if not self.output_folder:
                self.show_message("Error", "Failed to create output folder in the platform.", "critical")
                return
            
            # Get folder information
            out_folder_path = self.output_folder['folder']['folderLocal']
            folder_code = self.output_folder['folder']['code']
            folder_key = self.output_folder['folder']['key']
            
            # Create local directory
            os.makedirs(out_folder_path, exist_ok=True)
            
            published_files = []
            failed_exports = []
            
            # Get frame range for export
            export_start_frame, export_end_frame = self.get_export_frame_range()
            if export_start_frame is None:
                # Using scene default
                export_start_frame, export_end_frame = get_scene_frame_range()
            
            # Export each group separately (always per asset)
            for group in groups_to_export:
                try:
                    # Extract namespace from group
                    namespace = get_namespace_from_group(group)
                    
                    # Create filename following the convention: {namespace}_{folder_code}.abc
                    export_format = 'abc'
                    anim_filename = f"{namespace}_{folder_code}.{export_format}"
                    out_animation_path = os.path.join(out_folder_path, anim_filename)
                    
                    # Export animation to Alembic with custom frame range
                    if not export_animation_alembic(group, out_animation_path, export_start_frame, export_end_frame):
                        failed_exports.append(f"Failed to export group '{group}'")
                        continue
                    
                    # Create file entry in database
                    anim_file_data = create_file(anim_filename, folder_key)
                    if not anim_file_data:
                        failed_exports.append(f"Failed to create file entry for '{group}'")
                        continue
                    file_data = {
                        "name": anim_filename,
                        "path": out_animation_path,
                        "namespace": namespace,
                        "frame_range": (export_start_frame, export_end_frame)
                    }
                    data_write("File", anim_file_data["file"]["key"], "cache", file_data)

# Upload file to platform
                    upload_result = upload_file_to_platform(
                        out_animation_path,
                        anim_file_data["file"]["uploadLink"],
                        file_key=anim_file_data["file"]["key"]
                    )
                    
                    if upload_result:
                        published_files.append({
                            'group': group,
                            'filename': anim_filename,
                            'path': out_animation_path,
                            'namespace': namespace
                        })
                        print(f"Animation '{group}' published successfully:")
                        print(f"  - Filename: {anim_filename}")
                        print(f"  - Local path: {out_animation_path}")
                        print(f"  - Namespace: {namespace}")
                    else:
                        failed_exports.append(f"Failed to upload '{group}' to platform")
                        
                except Exception as e:
                    failed_exports.append(f"Error with group '{group}': {str(e)}")
            
            # Show results
            if published_files and not failed_exports:
                # All successful
                if len(published_files) == 1:
                    self.show_message("Success", f"Animation '{published_files[0]['group']}' published successfully as '{published_files[0]['filename']}'.")
                else:
                    self.show_message("Success", f"Successfully published {len(published_files)} animation groups.")
                self.accept()
            elif published_files and failed_exports:
                # Partial success
                success_msg = f"Successfully published {len(published_files)} groups.\n"
                failure_msg = f"Failed to publish {len(failed_exports)} groups:\n" + "\n".join(failed_exports)
                self.show_message("Partial Success", success_msg + failure_msg, "warning")
            else:
                # All failed
                failure_msg = "Failed to publish any animations:\n" + "\n".join(failed_exports)
                self.show_message("Error", failure_msg, "critical")
                
        except Exception as e:
            error_msg = f"An error occurred while publishing animations: {str(e)}"
            self.show_message("Error", error_msg, "critical")
            print(f"Error publishing animations: {e}")
            
        finally:
            # Re-enable the publish button
            self.publish_button.setEnabled(True)
            self.publish_button.setText("Publish Animation")
    
    def reject(self):
        """
        Override reject to close the dialog
        """
        super(AnimationPublisherDialog, self).reject()

def show_animation_publisher_dialog():
    """
    Main function to show the animation publisher dialog
    
    Returns:
        AnimationPublisherDialog: The dialog instance
    """
    dialog = AnimationPublisherDialog()
    dialog.show()
    return dialog

show_animation_publisher_dialog()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go