code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Nuke

Check Plates

Jorge Plaza 27/02/2025

Tags

Check Plates

Jorge Plaza

Action v4

27/02/2025

Nuke

Pseudo-Code

8	Method to retrieve plate information from platform
69	Method to build a read node in nuke with the new plate version data
87	Method to capture the current plate versions in the nuke script
103	Method to compare the local and platform versions
124	Strats main functionality
130	Extract the plate from the current comp with the latest version

Parameters

read_nodes	Read nodes in the current nuke script
plates_in_comp	Plates loaded in the current nuke script
plates_local	Dictionary storing the data of the plate with the latest version in the current nuke script
plates_db	Dictionary storing the data of the plate with the latest version in the platform
new_plates	The plate that will be loaded to the current script from platform

Talk with TD Support

Import to my Pipeline

Code

# CHECK NEW VERSIONS PLATE

import os
import pipeline
import nuke
import ast

def get_shot_plates_data(): # !!!! CHECKEAR SI ESTE METODO EXTRAE EL NOMBRE DEL SHOT
    """Returns a dict with all the plates and the path and frame range of each."""
    plates = []
    
    query = """
        query {
        file(fileName: "{filename}", token:"{token}"){
          folder {
            relTaskFolder{
              relShotTask{
                shot,
                data
              }
            }
          }
        }
      }
    """
    filepath = nuke.scriptName()
    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 plates
    print(response)
    file_props = response["file"]["folder"]["relTaskFolder"][0]["relShotTask"][0]["data"]
    shot_number = response["file"]["folder"]["relTaskFolder"][0]["relShotTask"][0]["shot"]
    print('FILE PROPS')
    print(file_props)
    if not file_props:
        # No plates versions published yet
        print(f"Warning: No plates versions published yet.")
        return plates
    plate_props = ast.literal_eval(file_props).get("plates_data", [])
    if type(plate_props) == str:
        plate_props = ast.literal_eval(plate_props)

# For each plate in the shot data
    for plate, plateVersionList in plate_props.items():
        print('PLATE')
        print(plate)
        if not plateVersionList:
            print(f"Plate {plate} do not have version published yet. Skipping...")
            continue
        plateData = plateVersionList[-1]
        plate_data = {
            "plates": plate,
            "shot_number":shot_number,
            "version": plateData["version"],
            "path": plateData["path"],
            "start": plateData["start"],
            "end": plateData["end"],
            "colorspace": plateData["colorspace"],
            "effect_nodes": plateData["effect_nodes"]
        }
        plates.append(plate_data)
    return plates

def build_read(plates):
    print('NEW PLATES TO BUILD: ')
    print(plates)
    #Builds the reads node in nuke for each plate
    for plate in plates:
        try:
            n = nuke.createNode('Read')
            n['name'].setValue(str(plate["shot_number"]) + "_" + plate["plates"] + "_v" + plate["version"])
            n['file'].setValue(plate["path"])
            n['first'].setValue(int(plate["start"]))
            n['last'].setValue(int(plate["end"]))
            n['colorspace'].setValue(plate["colorspace"])
            n['reload'].execute()

except Exception as e:
            print(f"Error creating Read node for {plate['plates']}: {e}")

def capture_plates(elements, tag):

element_list = []

for element in elements:
        element_path = element['file'].value()
        if tag in element_path: # Search for the 'Plate' nodes
            string = element_path.split(tag)[1]
            splitted_string = string.split('/')
            element_version = str(splitted_string[2])
            element_name = str(splitted_string[1])  
            element_list.append({tag: element_name, 'version': element_version})
        
    return element_list

def get_higher_version(local_data, db_data):

higher_version_data = []

# Get local data to compare
    for local_dict in local_data:
        local_name = local_dict["plates"]
        local_version = local_dict["version"]

# Get db data to compare
        for db_dict in db_data:
            db_name = db_dict["plates"]  
            db_version = db_dict["version"]

# Compare and operate
            if local_name == db_name and db_version > local_version:
                higher_version_data.append(db_dict)

return higher_version_data

#	MAIN FUNCIONALITY
# 1. Get the 'version of the current Plates in the comp
read_nodes = nuke.allNodes('Read')
plates_in_comp = capture_plates(read_nodes, 'plates')
latest_version = {}

for plates in plates_in_comp:
    plate = plates['plates']
    version = plates['version']
    
    if plate not in latest_version or version > latest_version[plate]['version']:
        latest_version[plate] = plates

plates_local = list(latest_version.values())

print(plates_local)

# 2. Get the latest 'version of the current Plates in DB
plates_db = get_shot_plates_data()

# 3. Check if they're the same
new_plates = get_higher_version(plates_local, plates_db)  # This is a dict, should be a list of dict
print (str(type(new_plates)) + 'NEW PALTES TO BUILD: ')
print(new_plates)

# 4. If its the same: Good Work!!
if not new_plates:
    nuke.message('No new versions found in platform!!')

# 5. If not: ask the user if they want to update and update if asked to
else:
    if nuke.ask('New plate versions found!! Would you like to load them?'):
        build_read(new_plates)

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go