code_gallery

Web News Blog Pricing

Learn

Training

Profiles

Executive Questions Harmony

Templates

Animation VFX

Code

Code Gallery Designer

v6.09

Hiero

Ingest Shots UI

Luis Miguel 18/12/2024

Tags

Ingest Shots

Ingest Shots UI

Luis Miguel

Action v3

18/12/2024

Hiero

Pseudo-Code

17	Query to the platform to collect Pipeline Data
442	Call to collect the clips selected from hiero
77	Using Hiero API, take the TrackItems selected (if any)
445	Open the UI to select the track and episode open a Table to select the shots to ingest
99	Open UI to select clips from a Track
460	From the selected Track, open a Table to select the shots to ingest
499	Creates a Thread to launch a webhook
479	Function to call a webhook with the message data given
482	Request to send a webhook with the data. Response returned

Parameters

Talk with TD Support

Import to my Pipeline

Code

# ----------------- Recargamos por si hay cambios
import pipeline
import importlib
import requests
import os
import threading

importlib.reload(pipeline)

# --------------------- Obtener el token para pasarlo al backend
documentos_path = os.path.join(os.environ['USERPROFILE'], 'Documents', 'kraken').replace('\\', '/')
cache_path = os.path.join(documentos_path, 'data').replace('\\', '/')

# -------------------- Listado de episodios
print('----------------------------------------------')
query_folder = '''
            query {
              myProject(token:"{token}"){
                handles
                fps: data(field:"project_fps")
                framePadding
                folderLocal
                resolution: data(field:"project_resolution")
                colorspace:data(field:"project_working_ColorSpace")
                working_space:data(field:"project_income_material_graphics_ColorSpace")
                relEpisodeProject {
                  code
                  key
                  deleted
                }
              }
              me(token:"{token}") {
                profile{
                  key
                }
              }
            }
                '''
response = pipeline.query(query_folder)
project_data = response['myProject']
episode_list = project_data['relEpisodeProject']
episode_list = {item['code']: item['key'] for item in episode_list if item['deleted'] is None}
dict(sorted(episode_list.items()))
profile_key = response['me']['profile']['key']
project_handles = project_data['handles'] or "5"
project_padding = project_data['framePadding'] or "1001"  # TODO: query from DB: project_data['padding']
project_settings = {
    "fps": project_data['fps'],
    "resolution": project_data['resolution'],
    "colorspace": "ACES",  # TODO: Get it from project settings.
    "working_space": project_data['working_space']
}
project_folder = response['myProject']['folderLocal']

# --------------------Ejecucion en Hiero
import hiero.core
import hiero.ui
from PySide2.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QFormLayout, QComboBox, QPushButton, QApplication, \
    QMessageBox, QLabel, QTableView, QLineEdit, QCheckBox
from PySide2.QtCore import QAbstractTableModel, Qt
import sys

def get_selected_items(sequence=None):
    # Get the active sequence from the timeline
    if not sequence:
        sequence = obtener_secuencia_activa()

# Getting selection
    te = hiero.ui.getTimelineEditor(sequence)
    selected_items = te.selection()

return selected_items

def get_items_by_type(node_type, selected=False):
    """Gets the items by the type given. For example: hiero.core.TrackItem"""
    sequence = obtener_secuencia_activa()
    item_list = []
    items_list_type = []

if selected:
        item_list = get_selected_items(sequence)
    else:
        # Loop through all tracks in the sequence
        for track in sequence.videoTracks():
            for item in track.items():
                item_list.append(item)

# Loop through the selected items
    for item in item_list:
        # Check if the item is a "node_type".
        if isinstance(item, node_type):
            items_list_type.append(item)

return items_list_type

def open_select_tracks(clips_selected=None):
    global app
    app = QApplication.instance()
    if app is None:
        app = QApplication(sys.argv)

dialog = QDialog()
    dialog.setWindowTitle("Selector de Pistas")
    dialog.setGeometry(100, 100, 300, 150)

screen_geometry = QApplication.desktop().screenGeometry()
    x = (screen_geometry.width() - dialog.width()) // 2
    y = (screen_geometry.height() - dialog.height()) // 2
    dialog.move(x, y)

layout_principal = QVBoxLayout()

select_track = QComboBox()
    select_episode = QComboBox()
    select_episode.setInsertPolicy(QComboBox.InsertAlphabetically)

# Labels
    label_select_track = QLabel('Select Track')
    label_select_episode = QLabel('Select Episode')

# Selection Checkbox
    new_selection_checkbox = QCheckBox("New Selection")
    new_selection_checkbox.hide()

secuencia_activa = obtener_secuencia_activa()

if secuencia_activa:
        video_tracks = secuencia_activa.videoTracks()
        video_tracks = tuple(reversed(video_tracks))
        select_track.addItems([track.name() for track in video_tracks])

for key, value in episode_list.items():
            select_episode.addItem(f"ep{key}", value)

else:
        QMessageBox.warning(dialog, "Advertencia", "No hay secuencia activa en Hiero.")

# Extra data
    extra_data_layout = QFormLayout()

# Queue
    label_set_queue = QLabel('Set Handles')
    set_queue = QLineEdit(project_handles)

# Head In
    label_set_padding = QLabel('Set Padding')
    set_padding = QLineEdit(project_padding)

# Form Layout
    extra_data_layout.addRow(label_set_queue, set_queue)
    extra_data_layout.addRow(label_set_padding, set_padding)

layout_principal.addWidget(label_select_track)
    layout_principal.addWidget(select_track)
    layout_principal.addWidget(new_selection_checkbox)
    layout_principal.addWidget(label_select_episode)
    layout_principal.addWidget(select_episode)
    layout_principal.addLayout(extra_data_layout)

boton_seleccionar = QPushButton("Select Clips")

# Variable para almacenar el resultado
    resultado = {}

# Preseleccion
    if clips_selected:
        single_clip = clips_selected[0]
        clip_track = single_clip.parent().name()
        print(f"Track Item from selection: {clip_track}")
        select_track.setCurrentText(clip_track)
        select_track.setEnabled(False)
        new_selection_checkbox.show()
        new_selection_checkbox.setChecked(False)
        boton_seleccionar.setText("Send")

def mostrar_seleccion():
        pista_seleccionada = select_track.currentText()
        episode_name = select_episode.currentText()
        episode_key = select_episode.currentData()
        queue = set_queue.text()
        padding = set_padding.text()
        from_selection = False

if not new_selection_checkbox.isChecked():
            # Get data from selected clips.
            # TODO_TD_PIPELINEPRO: Check if clips_selected belongs to the same Track
            from_selection = True

clips = get_all_clips(secuencia_activa, pista_seleccionada, episode_name, from_selection)

resultado['clips'] = clips
        resultado['episode_name'] = episode_name
        resultado['episode_key'] = episode_key
        resultado['queue'] = queue
        resultado['padding'] = padding
        resultado['is_selected'] = from_selection
        dialog.accept()  # Cierra el diálogo con estado aceptado

def selection_checkbox_changed():
        select_track.setEnabled(new_selection_checkbox.isChecked())

new_selection_checkbox.toggled.connect(selection_checkbox_changed)
    boton_seleccionar.clicked.connect(mostrar_seleccion)

layout_principal.addWidget(boton_seleccionar)

dialog.setLayout(layout_principal)

# Ejecuta el diálogo de manera modal y espera a que se cierre
    dialog.exec_()

# Retorna el resultado almacenado
    return resultado

def obtener_secuencia_activa():
    try:
        proyecto_activo = hiero.core.projects()[-1]
        secuencia_activa = hiero.ui.activeSequence()
        for secuencia in proyecto_activo.sequences():
            if secuencia.name() == secuencia_activa.name():
                return secuencia
    except Exception as e:
        print(f"Error al obtener la secuencia activa: {e}")
    return None

def get_clip_effect_data(clip):
    # TODO_TD_PIPELINEPRO: Ahora solo admite nodos Transform y Timewarp. Añadir nuevos effects.
    effect_data = {}
    # Iterar sobre los effects del TrackItem
    for effect in clip.linkedItems():
        # Comprobar si es un effect y es de tipo Transform
        if isinstance(effect, hiero.core.EffectTrackItem):
            effect_class = effect.node().Class()
            if effect_class == "Transform":
                transform_node = effect.node()
                # Propiedades del Transform
                effect_properties = {
                    'node_class': effect_class,
                    'translate': transform_node['translate'].getValue(),
                    'scale': transform_node['scale'].getValue(),
                    'rotate': transform_node['rotate'].getValue(),
                    'center': transform_node['center'].getValue()
                }
                effect_data.setdefault(effect.name(), effect_properties)
            elif effect_class == "TimeWarp":
                timewarp_node = effect.node()
                """
                node = nuke.selectedNode()
                node.knob("lookup").getExpression()
                node.knob("length").value()
                node.knob("filter").value()"""
                effect_properties = {
                    'node_class': effect_class,
                    'lookup': timewarp_node['lookup'].getValue(),
                    'length': timewarp_node['length'].getValue()
                }
                effect_data.setdefault(effect.name(), effect_properties)
    if clip.playbackSpeed() != 1.0:
        retime_properties = {
            'node_class': "Retime",
            'input.first': clip.sourceIn(),
            'input.last': clip.sourceOut(),
            'input.first_lock': 'true',
            'input.last_lock': 'true',
            'speed': clip.playbackSpeed()
        }
        effect_data.setdefault("Retime_node", retime_properties)
    return effect_data

def get_clip_data(clip):
    media_source = clip.source().mediaSource()
    media_path = media_source.fileinfos()[0].filename()
    effect_nodes = get_clip_effect_data(clip)

clip_data = {
        'shot_name': clip.name(),
        'video_input': media_path,
        'src_in': clip.sourceIn(),
        'src_out': clip.sourceOut(),
        'timeline_in': clip.timelineIn(),
        'timeline_out': clip.timelineOut(),
        'src_duration': clip.duration(),
        'effect_nodes': effect_nodes,
        'playback_speed': clip.playbackSpeed()
    }
    return clip_data

def get_all_clips(sequence, track_name, episode, from_selection=False):
    clips_list = []
    clips = []
    fps = sequence.framerate().toFloat()

if from_selection:
        # Clips selected:
        clips = get_items_by_type(hiero.core.TrackItem, selected=True)
    else:
        track = None
        for t in sequence.videoTracks():
            if t.name() == track_name:
                track = t
                break

if track is None:
            return 'Track does not exists.'
        track_name = track.name()
        clips = track.items()

for item in clips:
        clip_data = get_clip_data(item)
        # Add extra data
        clip_data['track_name'] = track_name
        clip_data['fps'] = fps
        clip_data['episode'] = episode

clips_list.append(clip_data)

return clips_list

class ShotTableModel(QAbstractTableModel):
    def __init__(self, shots, parent=None):
        super().__init__(parent)
        self.shots = shots
        self.headers = ["shot_name", "track_name", "src_in", "src_out", "timeline_in", "timeline_out",
                        "src_duration", "episode"]

def rowCount(self, parent=None):
        return len(self.shots)

def columnCount(self, parent=None):
        return len(self.headers)

def data(self, index, role=Qt.DisplayRole):
        if not index.isValid():
            return None
        if role == Qt.DisplayRole:
            key = self.headers[index.column()]
            return self.shots[index.row()].get(key, None)
        return None

def headerData(self, section, orientation, role=Qt.DisplayRole):
        if role == Qt.DisplayRole:
            if orientation == Qt.Horizontal:
                return self.headers[section]
            elif orientation == Qt.Vertical:
                return section + 1

def flags(self, index):
        if not index.isValid():
            return Qt.NoItemFlags
        return Qt.ItemIsEnabled | Qt.ItemIsSelectable

def selectedItems(self, indexes):
        selected_items = []
        for index in indexes:
            if index.isValid():
                selected_items.append(self.shots[index.row()])
        return selected_items

def sort(self, column, order):
        key = self.headers[column]
        self.layoutAboutToBeChanged.emit()
        self.shots.sort(key=lambda x: x[key], reverse=order == Qt.DescendingOrder)
        self.layoutChanged.emit()

def create_tableview_modal(shots):
    dialog = QDialog()
    dialog.setWindowTitle("Shot Details")
    dialog.setModal(True)
    dialog.resize(800, 450)
    screen_geometry = QApplication.desktop().screenGeometry()
    x = (screen_geometry.width() - dialog.width()) // 2
    y = (screen_geometry.height() - dialog.height()) // 2
    dialog.move(x, y)

layout = QVBoxLayout()

tableview = QTableView()

model = ShotTableModel(shots)
    tableview.setModel(model)

tableview.setSelectionBehavior(QTableView.SelectRows)  # Selecciona filas completas
    tableview.setSelectionMode(QTableView.MultiSelection)  # Modo de selección múltiple
    tableview.setEditTriggers(QTableView.NoEditTriggers)  # Deshabilitar edición al hacer doble clic

tableview.resizeColumnsToContents()

layout.addWidget(tableview)

# Select all layout:
    select_layout = QHBoxLayout()
    select_all_button = QPushButton("Select All")
    deselect_all_button = QPushButton("Deselect All")

select_layout.addWidget(select_all_button)
    select_layout.addWidget(deselect_all_button)

select_button = QPushButton("Seleccionar")

layout.addLayout(select_layout)
    layout.addWidget(select_button)

dialog.setLayout(layout)

# Lista para almacenar los elementos seleccionados
    selected_items = []

# Function to select all items
    def on_select_all():
        tableview.selectAll()

def on_deselect_all():
        tableview.clearSelection()

# Función para manejar el evento de clic en "Seleccionar"
    def on_select():
        nonlocal selected_items
        selected_indexes = tableview.selectionModel().selectedRows()
        selected_items = model.selectedItems(selected_indexes)
        dialog.accept()

# Signals:
    select_all_button.clicked.connect(on_select_all)
    deselect_all_button.clicked.connect(on_deselect_all)
    select_button.clicked.connect(on_select)

# Mostrar el diálogo y esperar hasta que se cierre
    dialog.exec_()

# Devolver los elementos seleccionados después de que se cierra el diálogo
    return selected_items

# Clips selected:
clips_list = get_items_by_type(hiero.core.TrackItem, selected=True)

# hiero_data se utilizará como un diccionario para recibir cualquier tipo de dato
hiero_data = open_select_tracks(clips_list)

clip_list = hiero_data.get('clips', [])

episode_seleccionado = hiero_data.get('episode_name', [])
episode_key = hiero_data.get('episode_key', [])
selected_queue = hiero_data.get('queue', "")
selected_padding = hiero_data.get("padding", "")
from_selected = hiero_data.get('is_selected', None)
selected_clips = []
# Get the clips previously selected or select the new ones.
if from_selected:
    selected_clips = clip_list
else:
    if len(clip_list) > 0:
        selected_clips = create_tableview_modal(clip_list)
print("Selected Clips:")
print(selected_clips)
endpoint = 'webhook_path'
token = 'token_logic_webhook'

message = {
    'profile_key': profile_key,
    'order': 'ingest_hiero_track',
    'episode_name': episode_seleccionado,
    'episode_key': episode_key,
    'clip_list': selected_clips,
    'handles': selected_queue,
    'padding': selected_padding,
    'project_settings': project_settings,
    'project_folder': project_folder
}

def call_to_web_hook(message):
    try:
        print('----------------------------------------')
        response = requests.post(endpoint + token + '/', json={'data': message})
        response_token = response.text
        response_token = json.loads(response_token)
        print(response)
    except Exception as e:
        print("Something wrong while sending Shots...")
        print('Error webhook', e)

msgBox = QMessageBox()
msg = "No Shots Selected."

if len(selected_clips) > 0:
    msg = f"A total of {len(selected_clips)} Shots sended to be processed!"
    print(msg)
    msgBox.setText(msg)
    msgBox.exec()
    threading.Thread(target=call_to_web_hook, args=(message,)).start()
else:
    msgBox.setText(msg)
    msgBox.exec_()

Import Action

1. Copy Key

Copy

2. Go to your Action pannel

Go