Prism Pipeline Integration

The Prism Pipeline integration is the largest single integration in Vibrante-Node, providing 62 nodes that expose Prism's studio management system to the node graph. Prism Pipeline is an open-source production pipeline management system covering asset tracking, shot management, version publishing, file path resolution, task assignment, and pipeline hook execution. Vibrante-Node wraps Prism's Python API so every pipeline operation — from querying asset lists to publishing rendered output — can be orchestrated visually as part of a larger automation graph.

The integration is designed for zero-wiring access to the Prism core object: you never need to pass a core handle between nodes. A single prism_core_init node in the graph triggers auto-bootstrap, and all subsequent prism_* nodes resolve the shared PrismCore instance automatically via resolve_prism_core(inputs).

---

How It Works

Auto-Bootstrap via prism_core_init

Prism's PrismCore initialisation is heavyweight: it reads project configuration files, connects to databases, and loads pipeline plugins. Running it inside a node's execute() coroutine on the asyncio thread would be unsafe, as Prism expects to initialise on the Qt main thread. Vibrante-Node handles this automatically:

1. Before execution starts, the engine scans the graph for a prism_core_init node.
2. If found, bootstrap_prism_core() is called on the Qt main thread via a blocking dispatch.
3. PrismCore.__init__() runs fully on the main thread and the instance is stored in a global cache (shared memory).
4. All prism_* nodes call resolve_prism_core(inputs) to retrieve the cached instance — no wiring required.

Vibrante-Node execution engine
        │
        ├─ detects prism_core_init node in graph
        ├─ calls bootstrap_prism_core() on Qt main thread (before exec starts)
        │   └─ PrismCore.__init__() — full Prism initialization
        │       └─ stored in shared memory / global cache
        │
        └─ prism_* nodes call resolve_prism_core(inputs)
            └─ reads from shared cache — no wiring required

resolve_prism_core(inputs)

This utility function in src/utils/prism_core.py performs a three-stage resolution:

1. Check inputs dict for a "core" key (backward compat — normally absent).
2. Check the process-level global cache (set by bootstrap).
3. Check shared memory (for multi-process setups).

If all three stages fail, it returns None. Nodes must guard against this and return a safe default with a helpful log message.

---

Node Skeleton

All Prism nodes follow the same pattern. Here is a complete reference implementation:

from src.nodes.base import BaseNode
from src.utils.prism_core import resolve_prism_core

class Prism_Get_Assets(BaseNode):
    name = "prism_get_assets"

    def __init__(self):
        super().__init__()
        # [AUTO-GENERATED-PORTS-START]
        self.add_input("entity", "string", widget_type="text")
        self.add_output("assets", "list")
        # [AUTO-GENERATED-PORTS-END]

    async def execute(self, inputs):
        core = resolve_prism_core(inputs)
        if core is None:
            self.log_error("PrismCore not available. Add prism_core_init to the graph.")
            return {"assets": [], "exec_out": True}
        try:
            assets = core.getAssets(entity=inputs.get("entity", ""))
            return {"assets": assets, "exec_out": True}
        except Exception as e:
            self.log_error(f"Prism error: {e}")
            return {"assets": [], "exec_out": True}

def register_node():
    return Prism_Get_Assets

Conventions every Prism node must follow:

• node_id must start with prism_.
• category must be "Prism".
• icon_path is "icons/prism_icon.png".
• Never add a core input port — it is resolved automatically.
• Always guard with if core is None and return a safe default.
• Use list(...) or {} as safe empty defaults for list/dict outputs.

---

Setup & Requirements

Prerequisites

1. Prism 2.x installed on the system. The integration targets Prism 2; Prism 1.x is not supported.
2. Prism's Python directory added to VIBRANTE_PYTHONPATH in Settings → Python Runtime. This allows Vibrante-Node's Python environment to import the PrismCore class.
3. A prism_core_init node placed anywhere in the graph (connect it to the exec chain before any other prism_* nodes).

Python Path Setup

Open Edit → Preferences… → Python Runtime and add the path to Prism's Python library directory. This is typically:

Platform	Typical Prism Python Path
Windows	C:/Prism2/Python311/Lib/site-packages
macOS	/Applications/Prism2/lib/python3.11/site-packages
Linux	/opt/prism2/lib/python3.11/site-packages

The exact path depends on your Prism installation directory. Check your Prism installation for the correct location.

Qt Compatibility

Prism imports Qt (PySide2 or PyQt5) at module load time. Vibrante-Node's src/utils/qt_compat.py compatibility layer provides the stubs and shims that Prism requires:

• QColor.fromString() — backported for Qt5 compatibility.
• Shiboken stubs — prevent ImportError on systems where shiboken2 is not installed.

This compatibility layer is loaded automatically at startup. You do not need to configure anything for it.

---

Node Library

The integration ships 62 nodes grouped by functional area. All nodes are in the Prism category.

Assets (12 nodes)

Node ID	Description
prism_get_assets	Get all assets for an entity (project, sequence, etc.).
prism_get_asset_info	Get detailed metadata for a specific asset.
prism_create_asset	Create a new asset in the Prism project database.
prism_get_asset_versions	List all published versions of an asset.
prism_get_latest_version	Get the most recent published version of an asset.
prism_get_asset_path	Resolve the filesystem path for an asset.
prism_set_asset_status	Set the production status of an asset (e.g. WIP, Review, Approved).
prism_get_assets_by_category	Filter assets by category (Characters, Props, Environments, etc.).
prism_get_departments	List all departments defined in the project.
prism_get_asset_tasks	Get all tasks assigned to a specific asset.
prism_get_task_info	Get detailed information about a specific task.
prism_get_asset_hierarchy	Get the full hierarchy tree for all assets in the project.

Shots (12 nodes)

Node ID	Description
prism_get_shots	Get all shots in a sequence or across the project.
prism_get_shot_info	Get detailed metadata for a specific shot.
prism_create_shot	Create a new shot in the project database.
prism_get_shot_versions	List all published versions for a shot.
prism_get_shot_path	Resolve the filesystem path for a shot.
prism_set_shot_status	Set the production status of a shot.
prism_get_sequences	List all sequences in the project.
prism_get_sequence_shots	Get all shots belonging to a specific sequence.
prism_get_shot_tasks	Get all tasks assigned to a specific shot.
prism_get_shot_frame_range	Get the start and end frame numbers for a shot.
prism_get_shot_camera	Get the camera file path associated with a shot.
prism_set_shot_frame_range	Update the frame range for a shot in the database.

Versions (10 nodes)

Node ID	Description
prism_publish_version	Publish a new version for an asset or shot, registering files in the Prism database.
prism_get_version_path	Get the filesystem path for a specific version number.
prism_get_version_info	Get full metadata for a specific published version.
prism_get_latest_version_path	Resolve the path to the latest published version directly.
prism_get_all_versions	List all versions across all assets or shots (filterable).
prism_set_version_status	Set the review status on a specific version.
prism_get_version_comment	Retrieve the artist comment attached to a version at publish time.
prism_copy_version	Copy an existing version to a new location or entity.
prism_get_version_dependencies	Get the list of upstream versions this version depends on.
prism_create_version	Create a version entry without publishing files (for registration workflows).

Files & Paths (8 nodes)

Node ID	Description
prism_get_scene_path	Get the DCC scene file path for an asset or shot.
prism_get_export_path	Get the export directory path for a specific asset/shot/task.
prism_get_render_path	Get the render output path following Prism's path conventions.
prism_get_playblast_path	Get the playblast output directory for a shot.
prism_open_scene	Open a DCC scene file registered in Prism (triggers the appropriate DCC application).
prism_save_scene	Save the current DCC scene back to its Prism-managed path.
prism_copy_file	Copy a file from one Prism-managed path to another.
prism_get_project_path	Get the root filesystem path of the current Prism project.

Users & Teams (6 nodes)

Node ID	Description
prism_get_users	List all users in the project.
prism_get_current_user	Get the currently logged-in Prism user.
prism_get_user_info	Get profile information for a specific user.
prism_get_teams	List all teams defined in the project.
prism_assign_task	Assign a task to a user or team.
prism_get_task_assignments	Get all current assignments for a task.

Project (6 nodes)

Node ID	Description
prism_get_project_info	Get metadata about the current Prism project.
prism_get_project_settings	Get pipeline settings configured for the project.
prism_get_categories	List all asset categories defined in the project.
prism_get_project_structure	Get the full folder structure definition for the project.
prism_get_custom_settings	Read custom key-value settings stored in the project config.
prism_get_project_name	Get the display name of the current Prism project.

Core (8 nodes)

Node ID	Description
prism_core_init	Triggers PrismCore bootstrap. Place this node in the exec chain before any other Prism nodes. Does not need to be wired to every Prism node — just to the exec chain.
prism_log	Write a message to the Prism activity log.
prism_get_config	Read a value from the Prism configuration file.
prism_set_config	Write a value to the Prism configuration file.
prism_run_hook	Execute a named Prism pipeline hook (e.g. postPublish, preExport).
prism_notify	Send a Prism notification to one or more users.
prism_send_message	Send a message through Prism's messaging system.
prism_get_pipeline_steps	List all pipeline steps defined for an entity.

---

Production Use Cases

Asset-Driven Rendering

Query all shots assigned to a specific sequence using prism_get_sequence_shots, retrieve the render path for each shot with prism_get_render_path, feed those paths into a Maya Headless or Blender Headless render graph, and publish the results back to Prism using prism_publish_version — all in a single execution run.

Version Publishing Automation

After a DCC operation completes (geometry export, simulation cache, rendered frames), use prism_publish_version to register the output files in the Prism version database. Combine with prism_set_version_status to automatically flag the version as ready for review.

# After Houdini simulation completes, publish the cache to Prism
sim_node  = scene.add_node_by_name("hou_run_sim",        (0, 0))
pub_node  = scene.add_node_by_name("prism_publish_version", (300, 0))
stat_node = scene.add_node_by_name("prism_set_version_status", (600, 0))

pub_node.set_parameter("entity", "shot_010")
pub_node.set_parameter("task",   "simulation")
pub_node.set_parameter("comment", "Auto-published by Vibrante-Node")
stat_node.set_parameter("status", "Review")

scene.connect_nodes(sim_node,  "output_path",   pub_node,  "file_paths")
scene.connect_nodes(sim_node,  "exec_out",      pub_node,  "exec_in")
scene.connect_nodes(pub_node,  "version_id",    stat_node, "version_id")
scene.connect_nodes(pub_node,  "exec_out",      stat_node, "exec_in")

Shot Status Dashboards

Build a reporting workflow that queries all shots across every sequence, collects their latest version status, and writes a JSON or CSV summary report. Use prism_get_sequences → prism_get_sequence_shots → prism_get_shot_versions → prism_get_version_info in a loop graph.

DCC-Agnostic Path Resolution

Use Prism's path conventions to build workflows that are not tied to any specific DCC application. prism_get_scene_path, prism_get_export_path, and prism_get_render_path return paths that follow the studio's naming conventions regardless of which DCC produced the files — making it straightforward to build cross-DCC pipelines.

Pipeline Hook Execution

Trigger Prism's built-in pipeline hooks from within a Vibrante-Node graph using prism_run_hook. This allows Vibrante-Node to participate in studio-wide pipeline events: fire a postPublish hook after publishing to notify downstream subscribers, or fire preRender to let Prism perform any pre-render setup steps defined by the studio pipeline team.

---

Troubleshooting

PrismCore not initialized

If a Prism node logs "PrismCore not available. Add prism_core_init to the graph.", verify that:

1. A prism_core_init node exists in the graph (check the node library — search for "prism_core_init").
2. The prism_core_init node is connected to the exec chain and runs before the failing node.
3. Prism's Python libraries are in VIBRANTE_PYTHONPATH (Settings → Python Runtime).

ImportError when loading Prism

If Prism fails to import during bootstrap, the error is printed to the log panel. Common causes:

• Prism's Python directory not added to VIBRANTE_PYTHONPATH.
• Prism installed for a different Python version (e.g. Prism ships with Python 3.9 but Vibrante-Node uses Python 3.11 — check version compatibility).
• Missing PySide2 dependency — Prism requires PySide2; if only PyQt5 is installed, the Qt compat layer provides stubs but full Prism UI functionality will be limited.