code_gallery

Web News Blog Press Pricing

Learn

Training

Profiles

Executive

Templates

VFX

Code

Code Gallery Designer

v5.20

Nuke

Sanity Check

Luis Miguel 05/12/2024

Tags

Sanity Check

Luis Miguel

Action v1

05/12/2024

Nuke

Pseudo-Code

646	main function. The beginning of the execution
653	Create the Sanity UI in nuke.
419	Class to create and edit the UI.
452	Define the UI element of the Sanity UI
469	Creates the First SectionGroupBox, with given data.
333	Class for SectionGroupBox UI
359	Define the UI element of the SectionGroupBox
383	Creates the SectionRow UI with data
244	Class for SectionRow UI, that define a row of a section with its events

Parameters

nuke_window	Main window of Nuke to open the UI
nuke_submit_window	The Main UI

Talk with TD Support

Import to my Pipeline

Code

#########   Nuke Sanity Check Template   ###########
##
## Version: 01
## Date: 05/12/2024 
##
## Property of: PipelinePro
##
#######################################################
# Imports
import re
import sys
import os
import nuke
import pipeline
# Pyside Imports
from PySide2.QtWidgets import (QDialog, QApplication, QWidget, QLabel, QVBoxLayout, QHBoxLayout, QComboBox,
                               QLineEdit, QGroupBox, QGridLayout,
                               QDoubleSpinBox, QRadioButton, QPushButton, QMessageBox, QCheckBox, QMainWindow,
                               QFormLayout)
from PySide2.QtCore import Signal, Qt

# Function Definition

def get_nuke_main_window():
    for widget in QApplication.topLevelWidgets():
        if isinstance(widget, QMainWindow):
            return widget
    return None

def get_project_settings(fields):
    settings = pipeline.api(
        call_type='query',
        operation='myProject',
        fields=fields
    )
    return settings

def get_project_settings_response():
    query_folder = '''
                query {
                  myProject(token:"{token}"){
                    name
                    handles
                    fps
                    framePadding
                    folderLocal
                    resolution: data(field:"project_resolution")
                    colorspace:data(field:"project_colorspace")
                    working_space:data(field:"project_income_material_graphics_ColorSpace")
                  }
                  me(token:"{token}") {
                    profile{
                      key
                    }
                  }
                }
                    '''
    response = pipeline.query(query_folder)
    project_data = response['myProject']
    project_name = project_data['name']
    project_settings = {
        "Project": project_name.replace(" ", "_"),
        "Fps": str(float(project_data['fps'])),
        "Color Management": "ACES",  # TODO: Get it from project settings.
        "Colorspace": "ACES - ACES2065-1"  # project_data['working_space']
    }

# Split resolution:
    main_res_dict = project_data['resolution']
    print(f"main_resolution: {main_res_dict}")
    main_resolution = f"{main_res_dict['name']} - {main_res_dict.get('width')}x{main_res_dict.get('height')}"
    project_settings.setdefault("Main Resolution", main_resolution)
    return project_settings

def get_nk_project_settings():
    nk_settings = {}
    root = nuke.root()
    if root:
        root_split = root.name().split("/")
        project_name = root_split[2] if len(root_split) > 3 else ""
        format_res = root.knob('format').value()
        resolution = f"{format_res.name()} - {format_res.width()}x{format_res.height()}"

nk_settings = {
            "Project": project_name,
            "Fps": root.knob('fps').value(),
            "Main Resolution": resolution,
            "Color Management": "ACES" if root.knob('colorManagement').value() == "OCIO" else "Nuke",
            "Colorspace": root.knob('workingSpaceLUT').value()
        }
    return nk_settings

def get_write_nodes(show_code):
    node_list = {}
    whitelist = [f"Write_EXR", f"Write_MOV"]
    for node in nuke.allNodes():
        if node.Class() == "Write":
            print(f"Write name: {node.name()}")
            if node.name() in whitelist:
                node_list.setdefault(node.name(), node)

return node_list

def get_write_settings(write_node):
    output_file = write_node.knob('file').value() or ""
    output_filename = os.path.basename(output_file).rsplit(".", 2)[0]
    write_settings = {
        "node_type": write_node.knob('file_type').value(),
        "output_file": output_file,
        "file_name": output_filename,
        "render_type": write_node.knob('render_type').value(),
        "render_name": write_node.knob('name_1').value(),
        "render_version": write_node.knob('version_1').value(),
        "render_colorspace": write_node.knob('colorspace').value()
    }
    if write_settings.get('node_type') == "exr":
        # Write EXR: Data from platform
        # Render: Format > exr > bits ("16 bit half") - compression (Zip (1 scanline))
        write_settings.setdefault("compression", write_node.knob("compression").value())
        write_settings.setdefault("bits", write_node.knob("datatype").value())

elif write_settings.get('node_type') == "mov":
        # Write MOV: data from platform:
        # Render: Format > mov > codec ("Apple ProRes 4:4:4:4 XQ 12-bits")
        try:
            codec_number = write_node.knob('mov64_codec').getValue()
            code_name = write_node.knob('mov64_codec').enumName(int(codec_number))
            split_name = code_name.split("\t")
            if len(split_name) > 1:
                code_name = split_name[-1]
            write_settings.setdefault("codec", code_name)
            write_settings.setdefault("codec_profile", write_node.knob("mov_prores_codec_profile").value())
        except Exception as e:
            print("Warning - Project Settings: Write Mov 'codec' could not be collected...")
            print(e)

elif write_settings.get('node_type') == "dnx":
        pass

return write_settings

def get_render_options():
    """Get render options from the project settings (platform) to check values.

Return:
        dict: Dictionary with the render settings set in the project.
    """
    # Loop throw all the render inputs set
    # Example: Format: EXR / Bits: 16 bit half / Compression: Zip (1 scanline)
    # Example2: Format: MOV / Codec: Apple ProRes / Codec Profile: ProRes 4:2:2 HQ 10-bit

render_options = {}
    # TODO_TD_PIPELINEPRO: Get render options from the platform
    # platform_render_options = Pipeline.Project.return_render_options()

# Simulation of dictionary collected from the platform.
    platform_render_options = [
        {
            "format": "exr",
            "bits": "16 bit half",
            "compression": "Zip (1 scanline)"
        },
        {
            "format": "mov",
            "codec": "Apple ProRes",
            "codec_profile": "ProRes 4:2:2 HQ 10-bit"
        }
    ]

for render_option in platform_render_options:
        render_format = render_option.get("format")
        if render_format:
            render_options.setdefault(render_format, render_option)

return render_options

def get_read_nodes():
    """Returns all the Read nodes from the script."""
    node_list = {}
    for node in nuke.allNodes():
        if node.Class() == "Read":
            node_list.setdefault(node.name(), node)

return node_list

def check_read_new_versions(read_node, project_settings):
    """Checks all the sanity for the Read node given: naming, version,..."""
    read_sanity_checks = {}
    # Plate path:
    # D:/TV_DEPARTMENT/DUMMIE_CURE/shots/CURE_115/CURE_115_001/CURE_115_001_0040/editorial/sources/CURE_115_001_0040_v001/CURE_115_001_0040_v001.####.exr

# Get read path:
    read_path = read_node.knob('file').value()
    directory = os.path.dirname(read_path)
    read_directory = os.path.dirname(directory)

# Read all versions
    read_name = read_node.knob('name').value()
    read_split = read_name.split("_v")[0]
    version_name = ""
    version = ""

# regex: capture without version
    regex_pattern = r'(?P<shot_name>[\w_]*)_(?P<version>v\d*)'
    match = re.match(regex_pattern, read_name)

versions_list = []
    new_version = ""
    if match:
        shot_name = match.group("shot_name")
        version = match.group("version")
        print(f"MATCH: {shot_name}")
        # Find the versions in the current read directory.
        for files_name in os.listdir(read_directory):
            file_shot_name = ""
            file_match = re.match(regex_pattern, files_name)
            if file_match:
                file_shot_name = file_match.group("shot_name")
            if file_shot_name == shot_name:
                # Shot name found, add the file into the list.
                versions_list.append(files_name)
        if len(versions_list) > 0:
            # Get the last version found
            last_version = sorted(versions_list)[-1]
            if read_name < last_version:
                print(f"New version available: {last_version}")
                new_version = last_version

#print(f"Read Version list: {versions_list}")
    read_sanity_checks.setdefault(read_node.name(), new_version)

return read_sanity_checks

class SectionRow(QWidget):
    def __init__(self, row_index, label, current_value, original_value=None, parent=None):
        super(SectionRow, self).__init__(parent=None)
        print("Creating Section Row")
        self._row = row_index
        self._label = label
        self._current_value = current_value
        self._original_value = original_value if original_value else ""
        self._parent = parent

# Build UI
        self.build_widget()
        # Connect signals
        self.connect_signals()

# Compare the original with the current value.
        self.refresh_ui()

def build_widget(self):
        """Builds the Row UI Widget."""
        print("Build Widget")
        ## Self code
        # Row label
        self.qt_label = QLabel(self._label)
        # Current value
        self.qt_current = QLineEdit(str(self._current_value))
        self.qt_current.setEnabled(False)
        # Original value
        self.qt_original = QLabel(self._original_value)
        # Change value button
        self.change_button = QPushButton("Change")
        self.change_button.setEnabled(False)

# Adding to the parent layout (grid layout)
        self._parent.addWidget(self.qt_label, self._row, 0)
        self._parent.addWidget(self.qt_current, self._row, 1)
        self._parent.addWidget(self.qt_original, self._row, 2)
        self._parent.addWidget(self.change_button, self._row, 3)

def connect_signals(self):
        """Connects the signals of every widget."""
        self.change_button.clicked.connect(self.change_item)

def change_item(self):
        """Callbacks when the change button is pressed. It changes the value of the QLineEdit."""
        original_value = self.qt_original.text()
        if original_value:
            self.qt_current.setText(original_value)
        else:
            print(f"No valid original value: {original_value}. Skipping set value...")
        # TODO_TD_PIPELINEPRO: Now it only modifies the UI, it should change the scene values.

self.refresh_ui()

def compare_values(self):
        """Compares the original with the current value."""
        # Red border to check values.
        current_value = self.qt_current.text()
        original_value = self.qt_original.text()
        if original_value:
            if current_value != original_value:
                self.qt_current.setStyleSheet("border: 1px solid red")
                print(f"Set True button")
                self.change_button.setEnabled(True)

def refresh_ui(self):
        """Checks the values and modify the UI."""
        print(f"REFRESH UI from Section")
        #self.compare_values()
        current_value = self.qt_current.text()
        original_value = self.qt_original.text()
        if original_value:
            # Red border to check values.
            if current_value != original_value:
                self.qt_current.setStyleSheet("border: 1px solid red")
                self.change_button.setEnabled(True)
            else:
                self.qt_current.setStyleSheet("border: 0px solid black")
                self.change_button.setEnabled(False)

def set_current_value(self, new_value):
        """Sets the new value into the current value."""
        self.qt_current.setText(new_value)

def set_original_value(self, new_value):
        """Sets the new value into the original value."""
        self.qt_original.setText(new_value)

class SectionGroupBox(QGroupBox):
    """Creates a collapsible section with a title and rows of text data.
    Parameters:
        title (str): Title of the section group.
        current_data (dict): The real values set in the scene.
        original_data(dict, optional): Data to check values from. (default=None)
        blacklist (list, optional): List of arguments to skip adding into the section. (default=None)
        parent(obj, optional): Parent of the current widget. (default=None)
    """
    def __init__(self, title, current_data, original_data=None, blacklist=None, parent=None):
        super(SectionGroupBox, self).__init__(parent=parent)
        print(f"Creating section: {title}")
        self.setTitle(title)
        self._current_data = current_data
        self._original_data = original_data
        self._blacklist = blacklist if blacklist else []
        self._parent = parent

self._group_row_widgets = []

# Create UI
        self.build_widget()

# Connect signals
        self.connect_signals()

def build_widget(self):
        # GroupBox for collapsible section
        #self._group_box = QGroupBox(self._title)
        self.setCheckable(True)

self.toggled.connect(self.toggle_section)

# Layout for the content inside the group box
        self._grid_layout = QGridLayout()

# Add the text data as rows
        row = 0
        print(f"Current data: {self._current_data.items()}")
        for label, value in self._current_data.items():
            # Skip labels from the blacklist
            if label in self._blacklist:
                continue
            key_label = str(label)
            print(f"Key label: {key_label}")

original_value = self._original_data.get(label, "")

print(f"Original value: {original_value}")
            # Creates the row widget
            row_widget = SectionRow(row, key_label, value, original_value, parent=self)
            self._group_row_widgets.append(row_widget)
            row += 1
        self.setLayout(self._grid_layout)

return

def connect_signals(self):
        pass

def refresh(self):
        """Refresh the UI elements. Call to its children."""
        print("Refresh from Section Group Box")
        for row_widget in self._group_row_widgets:
            row_widget.refresh_ui()

def toggle_section(self):
        """Toggle the visibility of the group box's content."""
        self.current_height = self.height()

for child in self.children():
            if isinstance(child, QWidget):
                if self.isChecked():
                    child.show()
                else:
                    child.hide()

# Window size changed
        height = self.height() if self.isChecked() else 0
        self.resize(self.width(), height)

def addWidget(self, label, row, column):
        """Overwrite adding widget section."""
        self._grid_layout.addWidget(label, row, column, alignment=Qt.AlignmentFlag.AlignLeft)

class NukeSettingsUI(QWidget):
    def __init__(self, project_name, parent=None):
        super(NukeSettingsUI, self).__init__(parent=parent)
        print("NukeSettings UI")
        self.setWindowTitle("Template Sanity Checks")
        self.setWindowFlags(Qt.Window)
        # Main layout
        self.main_layout = QVBoxLayout()

# Set the main window layout
        self.setLayout(self.main_layout)
        self.setMinimumHeight(350)

# Parameters

# Get Project Settings
        self.project_settings_data = get_project_settings_response()
        self.project_name = project_name  # self.project_settings_data['projectInitials']
        self.render_settings = get_render_options()

# Get script data to verify
        self.nk_write_nodes = get_write_nodes(self.project_name)  # List of writes nodes in the scene (WRITE_SHOWCODE(exr) and WRITE_SHOWCODE_MOV(mov))
        self.nk_read_nodes = get_read_nodes()
        self.nk_project_settings = get_nk_project_settings()

self.build_widget()

# Window size
        self.current_width = self.width()
        self.current_height = self.height()

self.connect_signals()

def build_widget(self):

# Header
        self.header = QHBoxLayout()
        self.section_label = QLabel("Section:")
        self.project_data_label = QLabel("Project data:")
        self.template_data_label = QLabel("Template data:")

self.header.addWidget(self.section_label)
        self.header.addWidget(self.template_data_label)
        self.header.addWidget(self.project_data_label)

# Create the sections
        project_data = {}
        for name, value in self.project_settings_data.items():
            project_data.setdefault(name, value)

self.project_settings_section = SectionGroupBox(
            "Project Settings",
            self.nk_project_settings,
            project_data,
            parent=self
        )

# TODO_TD_PIPELINER: CHECK Multiples writes nodes. Creates Multiples Sections
        write_data = {}
        write_data = {
            'exr': {},
            'mov': {}
        }
        # Get all Writes data
        for name, node in self.nk_write_nodes.items():
            write_settings = get_write_settings(node)
            node_type = write_settings.get('node_type')
            write_data[node_type] = write_settings

self.write_exr_nodes_section = SectionGroupBox(
            "Write EXR Nodes",
            write_data.get('exr', {}),
            self.render_settings.get('exr', {}),
            blacklist=["output_file", "node_type"]
        )

self.write_mov_nodes_section = SectionGroupBox(
            "Write MOV Nodes",
            write_data.get('mov', {}),
            self.render_settings.get('mov', {}),
            blacklist=["output_file", "node_type"]
        )

# Get Reads data
        read_data = {}
        read_check_data = {}
        for name, node in self.nk_read_nodes.items():
            file_path = node.knob('file').value() or ""
            output_filename = os.path.basename(file_path).rsplit(".", 2)[0]
            version_name = os.path.basename(output_filename)
            read_data.setdefault(name, version_name)
            # Check new versions from read nodes
            read_check_data = check_read_new_versions(node, self.project_settings_data)

self.read_nodes_section = SectionGroupBox(
            "Read Nodes",
            read_data,
            read_check_data
        )

self.refresh_button = QPushButton("Refresh")
        self.refresh_button.setEnabled(False)

# Add sections to the main layout
        self.main_layout.addLayout(self.header)
        self.main_layout.addWidget(self.project_settings_section)
        self.main_layout.addWidget(self.write_exr_nodes_section)
        self.main_layout.addWidget(self.write_mov_nodes_section)
        self.main_layout.addWidget(self.read_nodes_section)
        self.main_layout.addWidget(self.refresh_button)

def connect_signals(self):
        self.refresh_button.clicked.connect(self.refresh_ui)

def create_section(self, title, data, script_data=None, blacklist=None):
        """
        Create a collapsible section with a title and rows of text data.
        Args:
            blacklist (list, optional): List of arguments to skip adding into the section.
        """
        print(f"Creating section: {title}")
        blacklist = blacklist if blacklist else []
        # GroupBox for collapsible section
        group_box = QGroupBox(title)
        group_box.setCheckable(True)
        group_box.setChecked(True)
        group_box.toggled.connect(lambda: self.toggle_section(group_box))

# Layout for the content inside the group box
        grid_layout = QGridLayout()

# Add the text data as rows
        row = 0
        for label, value in data.items():
            # Skip labels from the blacklist
            if label in blacklist:
                continue
            key_label = f"{label}:"
            # Change button
            change_button = QPushButton("Change")

if script_data:
                script_value = script_data.get(label, "")
                qt_value = QLineEdit(value)
                qt_value.setEnabled(False)
                nk_value = QLabel(str(script_value))
                change_button = QPushButton("Change")
                change_button.setEnabled(False)

grid_layout.addWidget(QLabel(key_label), row, 0, alignment=Qt.AlignmentFlag.AlignLeft)
                grid_layout.addWidget(qt_value, row, 1, alignment=Qt.AlignmentFlag.AlignLeft)

if script_value:
                    grid_layout.addWidget(nk_value, row, 2, alignment=Qt.AlignmentFlag.AlignLeft)

grid_layout.addWidget(change_button, row, 3, alignment=Qt.AlignmentFlag.AlignLeft)

if script_value and script_value != value:
                    qt_value.setStyleSheet("border: 1px solid red")
                    print(f"Set True button")
                    change_button.setEnabled(True)
                    change_button.clicked.connect(lambda: self.change_item(qt_value, nk_value))
            else:
                qt_label = QLabel(key_label)
                qt_label.setAlignment(Qt.AlignLeft)
                qt_value = QLineEdit(value)
                qt_value.setEnabled(False)
                change_button = QPushButton("Change")
                change_button.setEnabled(False)

nk_value = QLineEdit("")
                nk_value.setEnabled(False)
                grid_layout.addWidget(qt_label, row, 0, alignment=Qt.AlignmentFlag.AlignLeft)
                grid_layout.addWidget(qt_value, row, 1, alignment=Qt.AlignmentFlag.AlignLeft)
                grid_layout.addWidget(change_button, row, 3, alignment=Qt.AlignmentFlag.AlignLeft)

# change_button.clicked.connect()

row += 1
        group_box.setLayout(grid_layout)

return group_box

def change_item(self, old_widget, new_widget):
        print(f"Old widget: {old_widget}")
        print(f"New widget: {new_widget}")
        new_value = new_widget.text()
        print(f"New value: {new_value}")
        old_widget.setText(new_value)

def refresh_ui(self):
        """TODO_TD_PIPELINEPRO: Refresh the UI if new values were changed in the script."""
        pass

def toggle_section(self, group_box):
        """Toggle the visibility of the group box's content."""
        modified_height = 0
        self.current_width = self.width()
        self.current_height = self.height()
        for child in group_box.children():
            if isinstance(child, QWidget):
                group_size = group_box.height()
                if group_box.isChecked():
                    child.show()
                    modified_height = self.height() + group_size
                else:
                    child.hide()
                    modified_height = self.height() - group_size
                # child.setVisible(group_box.isChecked())
        # Window size changed
        self.current_height = modified_height
        width = self.current_width
        height = self.current_height if self.current_height > 0 else 0
        self.resize(width, height)

def check_sanity_values(self):
        """Checks the sanity values in the nk to show information about errors or things to take care about."""
        # Check New versions in the scene: Read nodes

# Project Settings

# Writes data: version, file path, type

# Extra?
        pass

def main():
    nuke_window = get_nuke_main_window()
    print(f"--------------------Nuke window: {nuke_window}")
    if nuke_window is None:
        print("--------------------Error on creating UI in Nuke")
        return
    try:
        nuke_submit_window = NukeSettingsUI(project_name="CURE", parent=nuke_window)
        nuke_submit_window.show()
    except Exception as e:
        print(f"error: {e}")

print(F"OPEN TEST UI")

main()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go