Pipeline Management Integration

Prism Pipeline
Integration

Drive Prism Pipeline from a visual graph. Auto-resolve PrismCore, query assets and shots, publish product versions, manage scene files, and build full production automation workflows — all from connected nodes.

Browse Prism Nodes →Tutorial 7: Prism Asset Workflow →

Auto-Resolved PrismCore

Vibrante-Node uses a shared-memory bootstrap so you never need to wire core between nodes. Place one prism_core_init anywhere in the graph — the engine detects it before execution begins and bootstraps PrismCore on the Qt main thread. Every prism_* node that runs after it automatically inherits the same instance.

Without wiring
# prism_core_init detects once at startup
# All subsequent prism_* nodes just call:
from src.utils.prism_core import resolve_prism_core

async def execute(self, inputs):
    core = resolve_prism_core(inputs)
    if core is None:
        self.log_error("PrismCore not available.")
        return {"assets": [], "exec_out": True}
    assets = core.getAssets()
    return {"assets": assets, "exec_out": True}
⚡

Auto-bootstrap

prism_core_init triggers PrismCore.startup() on the Qt main thread before graph execution. Thread-safe via asyncio bridge.

🔗

No wiring required

resolve_prism_core() checks inputs, then a global cache, then shared memory. PrismCore is available everywhere.

🛡️

Safe fallback

If core is None (no init node in graph), each node logs an error and returns an empty safe default — no crash, no silent data loss.

Example: Multi-Asset Publisher

This is a real workflow pattern from the prism_multi_asset_publisher website example. It queries all project assets, iterates over each one, resolves export paths, and publishes a new version.

prism_multi_asset_publisher.vnw
1
prism_core_initBootstrap PrismCore — project path configured in node parameters
2
prism_get_assets_by_projectReturns list of all project assets as dicts [{asset, category, path, …}]
3
ForEach (loop)Iterates over each asset dict, exposing current_item per iteration
4
prism_get_export_pathResolves the versioned export path for the current asset's model product
5
prism_create_product_versionCreates a new version entry in Prism and returns the output path
6
Console PrintLogs: "Published {asset}: {output_path}"
prism_create_product_version node — execute()
async def execute(self, inputs):
    core = resolve_prism_core(inputs)
    if core is None:
        self.log_error("PrismCore not available.")
        return {"output_path": "", "exec_out": True}

    entity = inputs.get("entity", {})
    product_name = inputs.get("product_name", "model")
    comment = inputs.get("comment", "")

    try:
        # Prism v2.1.0 corrected createProduct signature
        result = core.createProductVersion(
            entity=entity,
            product=product_name,
            comment=comment
        )
        output_path = result.get("output_path", "")
        self.log_info(f"Published: {output_path}")
        return {"output_path": output_path, "exec_out": True}
    except Exception as e:
        self.log_error(f"Prism publish failed: {e}")
        return {"output_path": "", "exec_out": True}

Node Catalog

62 nodes across 6 functional groups. All node IDs start with prism_ and are grouped as category: "Prism" in the node library.

Core & Project
prism_core_initBootstrap PrismCore — place once in the graph, runs before any prism_* node
prism_core_infoRead current project name, version, and Prism installation info
prism_change_projectSwitch PrismCore to a different project by path
prism_create_projectCreate a new Prism project at a given path
prism_add_integrationAdd a DCC integration to the current project
Assets & Shots
prism_get_assets_by_projectList all assets in the current project, optionally filtered by type
prism_get_shotsList all shots (flat list, handles Prism v2.1 API)
prism_get_sequences_by_projectList all sequences for the current project
prism_create_entityCreate a new asset, shot, or sequence entity
prism_build_entityBuild a structured entity dict from name and type
Products & Versions
prism_get_productsList products for a given entity
prism_create_product_versionCreate a new product version (corrected createProduct signature for v2.1)
prism_create_categoryCreate a category inside an entity
Export Paths
prism_get_export_pathResolve the export path for an asset product version
prism_get_latest_product_pathResolve the latest published product file path for an entity
prism_create_playblastRegister a playblast media entry in Prism
Scene Management
prism_get_scene_filesList scene file versions for an entity/department
prism_save_scene_versionSave the current scene as a new version in the Prism project structure
prism_open_sceneOpen a specific scene file version
prism_get_scene_pathResolve the scene file path for a department/task in the current project
Media & Publishing
prism_get_mediaList media files for a shot or asset
prism_import_productImport a published product version into the current scene
prism_get_media_versionsList all media versions for a shot or asset entry

Authoring Prism Nodes

node_id starts with prism_

The registry rewrites core = inputs.get('core') → core = resolve_prism_core(inputs) for all matching nodes automatically.

category: "Prism"

Groups the node in the library panel and enables Prism-specific icon (icons/prism_icon.png).

No core input port

PrismCore is resolved automatically — never add a core port. Doing so makes the node harder to use and breaks the auto-wiring.

Guard with if core is None

If no prism_core_init is in the graph, core will be None. Always return a safe empty default instead of crashing.

Use list() for list outputs

Return list({...}) or [] — never return core.getAssets() directly, as it may be a generator or custom Prism iterable.

Tutorial 7: Prism Workflow

Step-by-step: core init → get assets → ForEach → get export path → log

→

Deadline Integration

Submit render jobs from Prism shot workflows to Thinkbox Deadline

→

Node Development

Write your own prism_* nodes following the SDK conventions

→