code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Maya

Set Maya Project

Jorge Hernandez Ibañez 31/07/2025

Tags
3d paths project

Set Maya Project

Jorge Herna…

Action v1

31/07/2025

Maya

Pseudo-Code

Parameters

MAYA_PROJECT_FOLDERS

The config of project folders inside the task

Talk with TD Support

Import to my Pipeline

Code

import pipeline
import maya.cmds as cmds
import os
import json

# Maya project folder structure configuration
# TODO: Make this configurable through UI or external config file
MAYA_PROJECT_FOLDERS = {
    "fluidCache": "cache/nCache/fluid",
    "data": "data",
    "images": "render",
    "offlineEdit": "scenes/edits",
    "furShadowMap": "renderData/fur/furShadowMap",
    "iprImages": "renderData/iprImages",
    "renderData": "renderData",
    "scripts": "scripts",
    "fileCache": "cache/nCache",
    "eps": "data",
    "shaders": "renderData/shaders",
    "3dPaintTextures": "sourceimages/3dPaintTextures",
    "mel": "scripts",
    "translatorData": "data",
    "exports": "exports",
    "assets": "assets",
    "furFiles": "renderData/fur/furFiles",
    "OBJ": "data",
    "particles": "cache/particles",
    "scene": "scene",
    "mayaLT": "",
    "alembicCache": "cache/alembic",
    "sourceImages": "sourceimages",
    "furEqualMap": "renderData/fur/furEqualMap",
    "furImages": "renderData/fur/furImages",
    "clips": "clips",
    "autosave": "autosave",
    "scenes": "scene",
    "cache": "cache",
    "depth": "renderData/depth",
    "sceneAssembly": "sceneAssembly",
    "teClipExports": "Time Editor/Clip Exports",
    "sourceimages": "sourceimages",
    "movie": "movies",
    "audio": "sound",
    "autoSave": "autosave",
    "mayaAscii": "scenes",
    "move": "data",
    "sound": "sound",
    "diskCache": "data",
    "illustrator": "data",
    "mayaBinary": "scene",
    "templates": "assets",
    "furAttrMap": "renderData/fur/furAttrMap",
    "timeEditor": "Time Editor"
}

def getTaskFolder(filename):
    """
    Get task folder path from pipeline based on filename
    """
    query = """
    query{
      file(fileName:"{filename}", token:"{token}"){
        fileName
        key
        task{
          name
          folderLocal
        }
      }
    }
    """
    query = query.replace("{filename}", filename)
    result = pipeline.query(query)
    if not result:
        return
    task = result.get("file", {}).get("task", {})
    return task.get("folderLocal")

def getCurrentMayaFile():
    """
    Get the current open Maya file path
    Returns None if no file is open or file is untitled
    """
    current_file = cmds.file(query=True, sceneName=True)
    
    # Check if file is saved (not empty and not untitled)
    if not current_file or "untitled" in current_file.lower():
        print("No saved Maya file is currently open")
        return None
    
    return current_file

def getCurrentMayaProject():
    """
    Get the currently set Maya project path
    """
    return cmds.workspace(query=True, rootDirectory=True)

def isMayaProject(folder_path):
    """
    Check if a folder contains a Maya project (workspace.mel file)
    """
    if not folder_path or not os.path.exists(folder_path):
        return False
    
    workspace_file = os.path.join(folder_path, "workspace.mel")
    return os.path.exists(workspace_file)

def createWorkspaceMelFile(project_path, maya_version="2024"):
    """
    Create workspace.mel file manually with proper Maya format
    """
    workspace_content = f"//Maya {maya_version} Project Definition\n\n"
    
    # Add each workspace rule
    for rule_name, folder_path in MAYA_PROJECT_FOLDERS.items():
        workspace_content += f'workspace -fr "{rule_name}" "{folder_path}";\n'
    
    # Write the workspace.mel file
    workspace_file = os.path.join(project_path, "workspace.mel")
    try:
        with open(workspace_file, 'w') as f:
            f.write(workspace_content)
        print(f"workspace.mel created at: {workspace_file}")
        return True
    except Exception as e:
        print(f"Error creating workspace.mel: {str(e)}")
        return False

def createMayaProject(project_path, project_name=None):
    """
    Create a new Maya project at the specified path by manually creating workspace.mel
    """
    if not project_name:
        project_name = os.path.basename(project_path.rstrip('/\\'))
    
    try:
        # Ensure the directory exists
        if not os.path.exists(project_path):
            os.makedirs(project_path)
        
        # Create all the project folders
        for rule_name, folder_path in MAYA_PROJECT_FOLDERS.items():
            if folder_path:  # Only create non-empty folder paths
                full_folder_path = os.path.join(project_path, folder_path)
                if not os.path.exists(full_folder_path):
                    os.makedirs(full_folder_path)
                    print(f"Created folder: {folder_path}")
        
        # Create the workspace.mel file manually
        if not createWorkspaceMelFile(project_path):
            return False
        
        # Verify workspace.mel was created
        workspace_file = os.path.join(project_path, "workspace.mel")
        if os.path.exists(workspace_file):
            print(f"Maya project created successfully at: {project_path}")
            return True
        else:
            print(f"Error: workspace.mel not found after creation")
            return False
        
    except Exception as e:
        print(f"Error creating Maya project: {str(e)}")
        return False

def setMayaProject(project_path):
    """
    Set/Open a Maya project
    """
    try:
        # Normalize the path
        project_path = os.path.normpath(project_path)
        
        if not isMayaProject(project_path):
            print(f"No Maya project found at: {project_path}")
            return False
        # Set the workspace in Maya
        cmds.workspace(project_path, openWorkspace=True)
        
        # Verify the project was set correctly
        current_project = cmds.workspace(q=True, fn=True)
        current_project = os.path.normpath(current_project)
        
        if current_project == project_path:
            print(f"Maya project successfully set to: {project_path}")
            return True
        else:
            print(f"Failed to set project. Current: {current_project}, Expected: {project_path}")
            return False
        
    except Exception as e:
        print(f"Error setting Maya project: {str(e)}")
        return False

def setupMayaProjectFromCurrentFile():
    """
    Main function to setup Maya project based on current open file
    This implements the complete workflow described in the requirements
    """
    # Step 1: Get the current open Maya file
    current_file = getCurrentMayaFile()
    if not current_file:
        print("Please save your Maya file first")
        return False
    
    print(f"Current Maya file: {current_file}")
    
    # Step 2: Use the Maya filename to get the task folder
    filename = os.path.basename(current_file)
    task_folder = getTaskFolder(filename)
    
    if not task_folder:
        print(f"Could not find task folder for file: {filename}")
        return False
    
    print(f"Task folder found: {task_folder}")
    
    # Step 3: Check if Maya has an open project that matches this location
    current_project = getCurrentMayaProject()
    
    # Normalize paths for comparison
    task_folder_normalized = os.path.normpath(task_folder)
    current_project_normalized = os.path.normpath(current_project) if current_project else ""
    
    if current_project_normalized == task_folder_normalized:
        print("Maya project already matches the task folder location")
        return True
    
    # Step 4: Check if that location has an existing Maya project
    if isMayaProject(task_folder):
        print("Existing Maya project found in task folder")
        return setMayaProject(task_folder)
    
    # Step 5: Create a Maya project in the task folder location
    print("No Maya project found in task folder. Creating new project...")
    
    # Create the project first
    if not createMayaProject(task_folder):
        print("Failed to create Maya project")
        return False
    
    # Verify it was created and then set it
    if isMayaProject(task_folder):
        print("Project created successfully, now setting as current project...")
        return setMayaProject(task_folder)
    else:
        print("Project creation failed - workspace.mel not found")
        return False

def configureMayaProjectFolders(custom_folders=None):
    """
    Future improvement: Configure Maya project folders
    This is a placeholder for future UI implementation
    
    Args:
        custom_folders (dict): Dictionary of Maya project folder rules
                              Format: {"rule_name": "folder_path"}
    """
    global MAYA_PROJECT_FOLDERS
    
    if custom_folders:
        MAYA_PROJECT_FOLDERS.update(custom_folders)
        print("Maya project folder configuration updated")
        
        # Optionally save to config file for persistence
        # saveProjectConfig(MAYA_PROJECT_FOLDERS)
    
    return MAYA_PROJECT_FOLDERS

def saveProjectConfig(config, config_path=None):
    """
    Save project configuration to file (future improvement)
    """
    if not config_path:
        # Default config location (could be user preferences or project specific)
        config_path = os.path.join(os.path.expanduser("~"), ".maya_project_config.json")
    
    try:
        with open(config_path, 'w') as f:
            json.dump(config, f, indent=2)
        print(f"Project configuration saved to: {config_path}")
    except Exception as e:
        print(f"Error saving config: {str(e)}")

def loadProjectConfig(config_path=None):
    """
    Load project configuration from file (future improvement)
    """
    global MAYA_PROJECT_FOLDERS
    
    if not config_path:
        config_path = os.path.join(os.path.expanduser("~"), ".maya_project_config.json")
    
    if os.path.exists(config_path):
        try:
            with open(config_path, 'r') as f:
                loaded_config = json.load(f)
            MAYA_PROJECT_FOLDERS.update(loaded_config)
            print(f"Project configuration loaded from: {config_path}")
        except Exception as e:
            print(f"Error loading config: {str(e)}")

# Initialize config on import (future improvement)
# loadProjectConfig()

# Main execution
setupMayaProjectFromCurrentFile()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go