Frame13/ayon-core
1
0
Fork 1
mirror of https://github.com/ynput/ayon-core.git synced 2025-12-24 21:04:40 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

nuke is using product name and type

Browse source
This commit is contained in:
Jakub Trllo 2024-02-23 11:40:46 +01:00
parent dda7e97088
commit 00436cf904
25 changed files with 240 additions and 200 deletions
Download patch file Download diff file Expand all files Collapse all files

69
client/ayon_core/hosts/nuke/api/lib.py
View file

@ -436,9 +436,9 @@ def set_avalon_knob_data(node, data=None, prefix="avalon:"):
Examples:
data = {
'asset': 'sq020sh0280',
'family': 'render',
'subset': 'subsetMain'
'folderPath': 'sq020sh0280',
'productType': 'render',
'productName': 'productMain'
}
"""
data = data or dict()
@ -662,7 +662,7 @@ def get_nuke_imageio_settings():
return get_project_settings(Context.project_name)["nuke"]["imageio"]
def get_imageio_node_setting(node_class, plugin_name, subset):
def get_imageio_node_setting(node_class, plugin_name, product_name):
''' Get preset data for dataflow (fileType, compression, bitDepth)
'''
imageio_nodes = get_nuke_imageio_settings()["nodes"]
@ -687,7 +687,7 @@ def get_imageio_node_setting(node_class, plugin_name, subset):
get_imageio_node_override_setting(
node_class,
plugin_name,
subset,
product_name,
imageio_node["knobs"]
)
@ -696,7 +696,7 @@ def get_imageio_node_setting(node_class, plugin_name, subset):
def get_imageio_node_override_setting(
node_class, plugin_name, subset, knobs_settings
node_class, plugin_name, product_name, knobs_settings
):
''' Get imageio node overrides from settings
'''
@ -707,7 +707,7 @@ def get_imageio_node_override_setting(
override_imageio_node = None
for onode in override_nodes:
log.debug("__ onode: {}".format(onode))
log.debug("__ subset: {}".format(subset))
log.debug("__ productName: {}".format(product_name))
if node_class not in onode["nuke_node_class"]:
continue
@ -717,7 +717,7 @@ def get_imageio_node_override_setting(
if (
onode["subsets"]
and not any(
re.search(s.lower(), subset.lower())
re.search(s.lower(), product_name.lower())
for s in onode["subsets"]
)
):
@ -868,16 +868,16 @@ def check_inventory_versions():
version_docs = get_versions(
project_name, version_ids, fields=["_id", "name", "parent"]
)
# Store versions by id and collect subset ids
# Store versions by id and collect product ids
version_docs_by_id = {}
subset_ids = set()
product_ids = set()
for version_doc in version_docs:
version_docs_by_id[version_doc["_id"]] = version_doc
subset_ids.add(version_doc["parent"])
product_ids.add(version_doc["parent"])
# Query last versions based on subset ids
last_versions_by_subset_id = get_last_versions(
project_name, subset_ids=subset_ids, fields=["_id", "parent"]
# Query last versions based on product ids
last_versions_by_product_id = get_last_versions(
project_name, subset_ids=product_ids, fields=["_id", "parent"]
)
# Loop through collected container nodes and their representation ids
@ -900,9 +900,9 @@ def check_inventory_versions():
).format(node.name()))
continue
# Get last version based on subset id
subset_id = version_doc["parent"]
last_version = last_versions_by_subset_id[subset_id]
# Get last version based on product id
product_id = version_doc["parent"]
last_version = last_versions_by_product_id[product_id]
# Check if last version is same as current version
if last_version["_id"] == version_doc["_id"]:
color_value = "0x4ecd25ff"
@ -959,19 +959,19 @@ def version_up_script():
nukescripts.script_and_write_nodes_version_up()
def check_subsetname_exists(nodes, subset_name):
def check_product_name_exists(nodes, product_name):
"""
Checking if node is not already created to secure there is no duplicity
Arguments:
nodes (list): list of nuke.Node objects
subset_name (str): name we try to find
product_name (str): name we try to find
Returns:
bool: True of False
"""
return next((True for n in nodes
if subset_name in read_avalon_data(n).get("subset", "")),
if product_name in read_avalon_data(n).get("productName", "")),
False)
@ -1012,8 +1012,12 @@ def format_anatomy(data):
)
data.update(context_data)
data.update({
"subset": data["subset"],
"family": data["family"],
"subset": data["productName"],
"family": data["productType"],
"product": {
"name": data["productName"],
"type": data["productType"],
},
"frame": "#" * padding,
})
return anatomy.format(data)
@ -1048,7 +1052,7 @@ def create_prenodes(
prev_node,
nodes_setting,
plugin_name=None,
subset=None,
product_name=None,
**kwargs
):
last_node = None
@ -1072,12 +1076,12 @@ def create_prenodes(
"dependent": node["dependent"]
}
if all([plugin_name, subset]):
if all([plugin_name, product_name]):
# find imageio overrides
get_imageio_node_override_setting(
now_node.Class(),
plugin_name,
subset,
product_name,
knobs
)
@ -1151,13 +1155,13 @@ def create_write_node(
# filtering variables
plugin_name = data["creator"]
subset = data["subset"]
product_name = data["productName"]
# get knob settings for write node
imageio_writes = get_imageio_node_setting(
node_class="Write",
plugin_name=plugin_name,
subset=subset
product_name=product_name
)
for knob in imageio_writes["knobs"]:
@ -1206,7 +1210,7 @@ def create_write_node(
prev_node,
prenodes,
plugin_name,
subset,
product_name,
**kwargs
)
if last_prenode:
@ -1839,14 +1843,17 @@ Reopening Nuke should synchronize these paths and resolve any discrepancies.
nuke_imageio_writes = None
if avalon_knob_data:
# establish families
families = [avalon_knob_data["family"]]
product_type = avalon_knob_data.get("productType")
if product_type is None:
product_type = avalon_knob_data["family"]
families = [product_type]
if avalon_knob_data.get("families"):
families.append(avalon_knob_data.get("families"))
nuke_imageio_writes = get_imageio_node_setting(
node_class=avalon_knob_data["families"],
plugin_name=avalon_knob_data["creator"],
subset=avalon_knob_data["subset"]
product_name=avalon_knob_data["productName"]
)
elif node_data:
nuke_imageio_writes = get_write_node_template_attr(node)
@ -2148,7 +2155,7 @@ def get_write_node_template_attr(node):
return get_imageio_node_setting(
node_class="Write",
plugin_name=plugin_names_mapping[identifier],
subset=node_data["subset"]
product_name=node_data["productName"]
)

52
client/ayon_core/hosts/nuke/api/pipeline.py
View file

@ -530,7 +530,7 @@ def list_instances(creator_id=None):
(list) of dictionaries matching instances format
"""
instances_by_order = defaultdict(list)
subset_instances = []
product_instances = []
instance_ids = set()
for node in nuke.allNodes(recurseGroups=True):
@ -568,51 +568,59 @@ def list_instances(creator_id=None):
else:
instance_ids.add(instance_id)
# node name could change, so update subset name data
_update_subset_name_data(instance_data, node)
# node name could change, so update product name data
_update_product_name_data(instance_data, node)
if "render_order" not in node.knobs():
subset_instances.append((node, instance_data))
product_instances.append((node, instance_data))
continue
order = int(node["render_order"].value())
instances_by_order[order].append((node, instance_data))
# Sort instances based on order attribute or subset name.
# Sort instances based on order attribute or product name.
# TODO: remove in future Publisher enhanced with sorting
ordered_instances = []
for key in sorted(instances_by_order.keys()):
instances_by_subset = defaultdict(list)
instances_by_product = defaultdict(list)
for node, data_ in instances_by_order[key]:
instances_by_subset[data_["subset"]].append((node, data_))
for subkey in sorted(instances_by_subset.keys()):
ordered_instances.extend(instances_by_subset[subkey])
product_name = data_.get("productName")
if product_name is None:
product_name = data_.get("subset")
instances_by_product[product_name].append((node, data_))
for subkey in sorted(instances_by_product.keys()):
ordered_instances.extend(instances_by_product[subkey])
instances_by_subset = defaultdict(list)
for node, data_ in subset_instances:
instances_by_subset[data_["subset"]].append((node, data_))
for key in sorted(instances_by_subset.keys()):
ordered_instances.extend(instances_by_subset[key])
instances_by_product = defaultdict(list)
for node, data_ in product_instances:
product_name = data_.get("productName")
if product_name is None:
product_name = data_.get("subset")
instances_by_product[product_name].append((node, data_))
for key in sorted(instances_by_product.keys()):
ordered_instances.extend(instances_by_product[key])
return ordered_instances
def _update_subset_name_data(instance_data, node):
"""Update subset name data in instance data.
def _update_product_name_data(instance_data, node):
"""Update product name data in instance data.
Args:
instance_data (dict): instance creator data
node (nuke.Node): nuke node
"""
# make sure node name is subset name
old_subset_name = instance_data["subset"]
# make sure node name is product name
old_product_name = instance_data.get("productName")
if old_product_name is None:
old_product_name = instance_data.get("subset")
old_variant = instance_data["variant"]
subset_name_root = old_subset_name.replace(old_variant, "")
product_name_root = old_product_name.replace(old_variant, "")
new_subset_name = node.name()
new_variant = new_subset_name.replace(subset_name_root, "")
new_product_name = node.name()
new_variant = new_product_name.replace(product_name_root, "")
instance_data["subset"] = new_subset_name
instance_data["productName"] = new_product_name
instance_data["variant"] = new_variant

99
client/ayon_core/hosts/nuke/api/plugin.py
View file

@ -34,7 +34,7 @@ from ayon_core.lib.transcoding import (
from .lib import (
INSTANCE_DATA_KNOB,
Knobby,
check_subsetname_exists,
check_product_name_exists,
maintained_selection,
get_avalon_knob_data,
set_avalon_knob_data,
@ -87,15 +87,15 @@ class NukeCreator(NewCreator):
for pass_key in keys:
creator_attrs[pass_key] = pre_create_data[pass_key]
def check_existing_subset(self, subset_name):
"""Make sure subset name is unique.
def check_existing_product(self, product_name):
"""Make sure product name is unique.
It search within all nodes recursively
and checks if subset name is found in
and checks if product name is found in
any node having instance data knob.
Arguments:
subset_name (str): Subset name
product_name (str): Subset name
"""
for node in nuke.allNodes(recurseGroups=True):
@ -108,14 +108,14 @@ class NukeCreator(NewCreator):
# a node has no instance data
continue
# test if subset name is matching
if node_data.get("subset") == subset_name:
# test if product name is matching
if node_data.get("productType") == product_name:
raise NukeCreatorError(
(
"A publish instance for '{}' already exists "
"in nodes! Please change the variant "
"name to ensure unique output."
).format(subset_name)
).format(product_name)
)
def create_instance_node(
@ -167,22 +167,22 @@ class NukeCreator(NewCreator):
else:
self.selected_nodes = []
def create(self, subset_name, instance_data, pre_create_data):
def create(self, product_name, instance_data, pre_create_data):
# make sure selected nodes are added
self.set_selected_nodes(pre_create_data)
# make sure subset name is unique
self.check_existing_subset(subset_name)
# make sure product name is unique
self.check_existing_product(product_name)
try:
instance_node = self.create_instance_node(
subset_name,
product_name,
node_type=instance_data.pop("node_type", None)
)
instance = CreatedInstance(
self.family,
subset_name,
self.product_type,
product_name,
instance_data,
self
)
@ -227,10 +227,10 @@ class NukeCreator(NewCreator):
for created_inst, changes in update_list:
instance_node = created_inst.transient_data["node"]
# update instance node name if subset name changed
if "subset" in changes.changed_keys:
# update instance node name if product name changed
if "productName" in changes.changed_keys:
instance_node["name"].setValue(
changes["subset"].new_value
changes["productName"].new_value
)
# in case node is not existing anymore (user erased it manually)
@ -271,7 +271,7 @@ class NukeWriteCreator(NukeCreator):
identifier = "create_write"
label = "Create Write"
family = "write"
product_type = "write"
icon = "sign-out"
def get_linked_knobs(self):
@ -355,22 +355,22 @@ class NukeWriteCreator(NukeCreator):
label="Review"
)
def create(self, subset_name, instance_data, pre_create_data):
def create(self, product_name, instance_data, pre_create_data):
# make sure selected nodes are added
self.set_selected_nodes(pre_create_data)
# make sure subset name is unique
self.check_existing_subset(subset_name)
# make sure product name is unique
self.check_existing_product(product_name)
instance_node = self.create_instance_node(
subset_name,
product_name,
instance_data
)
try:
instance = CreatedInstance(
self.family,
subset_name,
self.product_type,
product_name,
instance_data,
self
)
@ -871,8 +871,8 @@ class ExporterReviewMov(ExporterReview):
self.log.info(
"__ add_custom_tags: `{0}`".format(add_custom_tags))
subset = self.instance.data["subset"]
self._temp_nodes[subset] = []
product_name = self.instance.data["productName"]
self._temp_nodes[product_name] = []
# Read node
r_node = nuke.createNode("Read")
@ -892,7 +892,9 @@ class ExporterReviewMov(ExporterReview):
r_node["raw"].setValue(1)
# connect to Read node
self._shift_to_previous_node_and_temp(subset, r_node, "Read... `{}`")
self._shift_to_previous_node_and_temp(
product_name, r_node, "Read... `{}`"
)
# add reformat node
reformat_nodes_config = kwargs["reformat_nodes_config"]
@ -906,7 +908,7 @@ class ExporterReviewMov(ExporterReview):
# connect in order
self._connect_to_above_nodes(
node, subset, "Reposition node... `{}`"
node, product_name, "Reposition node... `{}`"
)
# append reformated tag
add_tags.append("reformated")
@ -918,7 +920,9 @@ class ExporterReviewMov(ExporterReview):
ipn = get_view_process_node()
if ipn is not None:
# connect to ViewProcess node
self._connect_to_above_nodes(ipn, subset, "ViewProcess... `{}`")
self._connect_to_above_nodes(
ipn, product_name, "ViewProcess... `{}`"
)
if not self.viewer_lut_raw:
# OCIODisplay
@ -942,7 +946,9 @@ class ExporterReviewMov(ExporterReview):
view=viewer
)
self._connect_to_above_nodes(dag_node, subset, "OCIODisplay... `{}`")
self._connect_to_above_nodes(
dag_node, product_name, "OCIODisplay... `{}`"
)
# Write node
write_node = nuke.createNode("Write")
self.log.debug("Path: {}".format(self.path))
@ -969,8 +975,10 @@ class ExporterReviewMov(ExporterReview):
write_node["raw"].setValue(1)
# connect
write_node.setInput(0, self.previous_node)
self._temp_nodes[subset].append(write_node)
self.log.debug("Write... `{}`".format(self._temp_nodes[subset]))
self._temp_nodes[product_name].append(write_node)
self.log.debug("Write... `{}`".format(
self._temp_nodes[product_name])
)
# ---------- end nodes creation
# ---------- render or save to nk
@ -995,19 +1003,19 @@ class ExporterReviewMov(ExporterReview):
self.log.debug("Representation... `{}`".format(self.data))
self.clean_nodes(subset)
self.clean_nodes(product_name)
nuke.scriptSave()
return self.data
def _shift_to_previous_node_and_temp(self, subset, node, message):
self._temp_nodes[subset].append(node)
def _shift_to_previous_node_and_temp(self, product_name, node, message):
self._temp_nodes[product_name].append(node)
self.previous_node = node
self.log.debug(message.format(self._temp_nodes[subset]))
self.log.debug(message.format(self._temp_nodes[product_name]))
def _connect_to_above_nodes(self, node, subset, message):
def _connect_to_above_nodes(self, node, product_name, message):
node.setInput(0, self.previous_node)
self._shift_to_previous_node_and_temp(subset, node, message)
self._shift_to_previous_node_and_temp(product_name, node, message)
def convert_to_valid_instaces():
@ -1015,7 +1023,7 @@ def convert_to_valid_instaces():
Also save as new minor version of workfile.
"""
def family_to_identifier(family):
def product_type_to_identifier(product_type):
mapping = {
"render": "create_write_render",
"prerender": "create_write_prerender",
@ -1027,7 +1035,7 @@ def convert_to_valid_instaces():
"source": "create_source"
}
return mapping[family]
return mapping[product_type]
from ayon_core.hosts.nuke.api import workio
@ -1086,7 +1094,10 @@ def convert_to_valid_instaces():
transfer_data["task"] = task_name
family = avalon_knob_data["family"]
product_type = avalon_knob_data.get("productType")
if product_type is None:
product_type = avalon_knob_data["family"]
# establish families
families_ak = avalon_knob_data.get("families", [])
@ -1104,11 +1115,13 @@ def convert_to_valid_instaces():
node["publish"].value())
# add idetifier
transfer_data["creator_identifier"] = family_to_identifier(family)
transfer_data["creator_identifier"] = product_type_to_identifier(
product_type
)
# Add all nodes in group instances.
if node.Class() == "Group":
# only alter families for render family
# only alter families for render product type
if families_ak and "write" in families_ak.lower():
target = node["render"].value()
if target == "Use existing frames":

10
client/ayon_core/hosts/nuke/plugins/create/create_backdrop.py
View file

@ -12,7 +12,7 @@ class CreateBackdrop(NukeCreator):
identifier = "create_backdrop"
label = "Nukenodes (backdrop)"
family = "nukenodes"
product_type = "nukenodes"
icon = "file-archive-o"
maintain_selection = True
@ -38,12 +38,12 @@ class CreateBackdrop(NukeCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
# make sure subset name is unique
self.check_existing_subset(subset_name)
def create(self, product_name, instance_data, pre_create_data):
# make sure product name is unique
self.check_existing_product(product_name)
instance = super(CreateBackdrop, self).create(
subset_name,
product_name,
instance_data,
pre_create_data
)

10
client/ayon_core/hosts/nuke/plugins/create/create_camera.py
View file

@ -14,7 +14,7 @@ class CreateCamera(NukeCreator):
identifier = "create_camera"
label = "Camera (3d)"
family = "camera"
product_type = "camera"
icon = "camera"
# plugin attributes
@ -44,12 +44,12 @@ class CreateCamera(NukeCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
# make sure subset name is unique
self.check_existing_subset(subset_name)
def create(self, product_name, instance_data, pre_create_data):
# make sure product name is unique
self.check_existing_product(product_name)
instance = super(CreateCamera, self).create(
subset_name,
product_name,
instance_data,
pre_create_data
)

10
client/ayon_core/hosts/nuke/plugins/create/create_gizmo.py
View file

@ -11,7 +11,7 @@ class CreateGizmo(NukeCreator):
identifier = "create_gizmo"
label = "Gizmo (group)"
family = "gizmo"
product_type = "gizmo"
icon = "file-archive-o"
default_variants = ["ViewerInput", "Lut", "Effect"]
@ -42,12 +42,12 @@ class CreateGizmo(NukeCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
# make sure subset name is unique
self.check_existing_subset(subset_name)
def create(self, product_name, instance_data, pre_create_data):
# make sure product name is unique
self.check_existing_product(product_name)
instance = super(CreateGizmo, self).create(
subset_name,
product_name,
instance_data,
pre_create_data
)

10
client/ayon_core/hosts/nuke/plugins/create/create_model.py
View file

@ -11,7 +11,7 @@ class CreateModel(NukeCreator):
identifier = "create_model"
label = "Model (3d)"
family = "model"
product_type = "model"
icon = "cube"
default_variants = ["Main"]
@ -42,12 +42,12 @@ class CreateModel(NukeCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
# make sure subset name is unique
self.check_existing_subset(subset_name)
def create(self, product_name, instance_data, pre_create_data):
# make sure product name is unique
self.check_existing_product(product_name)
instance = super(CreateModel, self).create(
subset_name,
product_name,
instance_data,
pre_create_data
)

16
client/ayon_core/hosts/nuke/plugins/create/create_source.py
View file

@ -17,7 +17,7 @@ class CreateSource(NukeCreator):
identifier = "create_source"
label = "Source (read)"
family = "source"
product_type = "source"
icon = "film"
default_variants = ["Effect", "Backplate", "Fire", "Smoke"]
@ -35,7 +35,7 @@ class CreateSource(NukeCreator):
return read_node
def create(self, subset_name, instance_data, pre_create_data):
def create(self, product_name, instance_data, pre_create_data):
# make sure selected nodes are added
self.set_selected_nodes(pre_create_data)
@ -46,18 +46,18 @@ class CreateSource(NukeCreator):
continue
node_name = read_node.name()
_subset_name = subset_name + node_name
_product_name = product_name + node_name
# make sure subset name is unique
self.check_existing_subset(_subset_name)
# make sure product name is unique
self.check_existing_product(_product_name)
instance_node = self.create_instance_node(
_subset_name,
_product_name,
read_node
)
instance = CreatedInstance(
self.family,
_subset_name,
self.product_type,
_product_name,
instance_data,
self
)

22
client/ayon_core/hosts/nuke/plugins/create/create_write_image.py
View file

@ -18,7 +18,7 @@ from ayon_core.hosts.nuke.api.plugin import exposed_write_knobs
class CreateWriteImage(napi.NukeWriteCreator):
identifier = "create_write_image"
label = "Image (write)"
family = "image"
product_type = "image"
icon = "sign-out"
instance_attributes = [
@ -64,18 +64,18 @@ class CreateWriteImage(napi.NukeWriteCreator):
default=nuke.frame()
)
def create_instance_node(self, subset_name, instance_data):
def create_instance_node(self, product_name, instance_data):
# add fpath_template
write_data = {
"creator": self.__class__.__name__,
"subset": subset_name,
"productName": product_name,
"fpath_template": self.temp_rendering_path_template
}
write_data.update(instance_data)
created_node = napi.create_write_node(
subset_name,
product_name,
write_data,
input=self.selected_node,
prenodes=self.prenodes,
@ -91,8 +91,8 @@ class CreateWriteImage(napi.NukeWriteCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
subset_name = subset_name.format(**pre_create_data)
def create(self, product_name, instance_data, pre_create_data):
product_name = product_name.format(**pre_create_data)
# pass values from precreate to instance
self.pass_pre_attributes_to_instance(
@ -107,18 +107,18 @@ class CreateWriteImage(napi.NukeWriteCreator):
# make sure selected nodes are added
self.set_selected_nodes(pre_create_data)
# make sure subset name is unique
self.check_existing_subset(subset_name)
# make sure product name is unique
self.check_existing_product(product_name)
instance_node = self.create_instance_node(
subset_name,
product_name,
instance_data,
)
try:
instance = CreatedInstance(
self.family,
subset_name,
self.product_type,
product_name,
instance_data,
self
)

20
client/ayon_core/hosts/nuke/plugins/create/create_write_prerender.py
View file

@ -15,7 +15,7 @@ from ayon_core.hosts.nuke.api.plugin import exposed_write_knobs
class CreateWritePrerender(napi.NukeWriteCreator):
identifier = "create_write_prerender"
label = "Prerender (write)"
family = "prerender"
product_type = "prerender"
icon = "sign-out"
instance_attributes = [
@ -45,11 +45,11 @@ class CreateWritePrerender(napi.NukeWriteCreator):
]
return attr_defs
def create_instance_node(self, subset_name, instance_data):
def create_instance_node(self, product_name, instance_data):
# add fpath_template
write_data = {
"creator": self.__class__.__name__,
"subset": subset_name,
"productName": product_name,
"fpath_template": self.temp_rendering_path_template
}
@ -64,7 +64,7 @@ class CreateWritePrerender(napi.NukeWriteCreator):
width, height = (actual_format.width(), actual_format.height())
created_node = napi.create_write_node(
subset_name,
product_name,
write_data,
input=self.selected_node,
prenodes=self.prenodes,
@ -81,7 +81,7 @@ class CreateWritePrerender(napi.NukeWriteCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
def create(self, product_name, instance_data, pre_create_data):
# pass values from precreate to instance
self.pass_pre_attributes_to_instance(
instance_data,
@ -94,18 +94,18 @@ class CreateWritePrerender(napi.NukeWriteCreator):
# make sure selected nodes are added
self.set_selected_nodes(pre_create_data)
# make sure subset name is unique
self.check_existing_subset(subset_name)
# make sure product name is unique
self.check_existing_product(product_name)
instance_node = self.create_instance_node(
subset_name,
product_name,
instance_data
)
try:
instance = CreatedInstance(
self.family,
subset_name,
self.product_type,
product_name,
instance_data,
self
)

20
client/ayon_core/hosts/nuke/plugins/create/create_write_render.py
View file

@ -15,7 +15,7 @@ from ayon_core.hosts.nuke.api.plugin import exposed_write_knobs
class CreateWriteRender(napi.NukeWriteCreator):
identifier = "create_write_render"
label = "Render (write)"
family = "render"
product_type = "render"
icon = "sign-out"
instance_attributes = [
@ -39,11 +39,11 @@ class CreateWriteRender(napi.NukeWriteCreator):
]
return attr_defs
def create_instance_node(self, subset_name, instance_data):
def create_instance_node(self, product_name, instance_data):
# add fpath_template
write_data = {
"creator": self.__class__.__name__,
"subset": subset_name,
"productName": product_name,
"fpath_template": self.temp_rendering_path_template
}
@ -61,7 +61,7 @@ class CreateWriteRender(napi.NukeWriteCreator):
self.log.debug(">>>>>>> : {}".format(self.get_linked_knobs()))
created_node = napi.create_write_node(
subset_name,
product_name,
write_data,
input=self.selected_node,
prenodes=self.prenodes,
@ -76,7 +76,7 @@ class CreateWriteRender(napi.NukeWriteCreator):
return created_node
def create(self, subset_name, instance_data, pre_create_data):
def create(self, product_name, instance_data, pre_create_data):
# pass values from precreate to instance
self.pass_pre_attributes_to_instance(
instance_data,
@ -88,18 +88,18 @@ class CreateWriteRender(napi.NukeWriteCreator):
# make sure selected nodes are added
self.set_selected_nodes(pre_create_data)
# make sure subset name is unique
self.check_existing_subset(subset_name)
# make sure product name is unique
self.check_existing_product(product_name)
instance_node = self.create_instance_node(
subset_name,
product_name,
instance_data
)
try:
instance = CreatedInstance(
self.family,
subset_name,
self.product_type,
product_name,
instance_data,
self
)

6
client/ayon_core/hosts/nuke/plugins/create/workfile_creator.py
View file

@ -13,7 +13,7 @@ import nuke
class WorkfileCreator(AutoCreator):
identifier = "workfile"
family = "workfile"
product_type = "workfile"
default_variant = "Main"
@ -32,7 +32,7 @@ class WorkfileCreator(AutoCreator):
host_name = self.create_context.host_name
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
product_name = self.get_product_name(
self.default_variant, task_name, asset_doc,
project_name, host_name
)
@ -47,7 +47,7 @@ class WorkfileCreator(AutoCreator):
))
instance = CreatedInstance(
self.family, subset_name, instance_data, self
self.product_type, product_name, instance_data, self
)
instance.transient_data["node"] = root_node
self._add_instance_to_context(instance)

9
client/ayon_core/hosts/nuke/plugins/publish/collect_gizmo.py
View file

@ -15,8 +15,8 @@ class CollectGizmo(pyblish.api.InstancePlugin):
gizmo_node = instance.data["transientData"]["node"]
# add family to familiess
instance.data["families"].insert(0, instance.data["family"])
# add product type to familiess
instance.data["families"].insert(0, instance.data["productType"])
# make label nicer
instance.data["label"] = gizmo_node.name()
@ -25,6 +25,7 @@ class CollectGizmo(pyblish.api.InstancePlugin):
handle_end = instance.context.data["handleEnd"]
first_frame = int(nuke.root()["first_frame"].getValue())
last_frame = int(nuke.root()["last_frame"].getValue())
families = [instance.data["productType"]] + instance.data["families"]
# Add version data to instance
version_data = {
@ -33,8 +34,8 @@ class CollectGizmo(pyblish.api.InstancePlugin):
"frameStart": first_frame + handle_start,
"frameEnd": last_frame - handle_end,
"colorspace": nuke.root().knob('workingSpaceLUT').value(),
"families": [instance.data["family"]] + instance.data["families"],
"subset": instance.data["subset"],
"families": families,
"productName": instance.data["productName"],
"fps": instance.context.data["fps"]
}

10
client/ayon_core/hosts/nuke/plugins/publish/collect_model.py
View file

@ -15,8 +15,8 @@ class CollectModel(pyblish.api.InstancePlugin):
geo_node = instance.data["transientData"]["node"]
# add family to familiess
instance.data["families"].insert(0, instance.data["family"])
# add product type to familiess
instance.data["families"].insert(0, instance.data["productType"])
# make label nicer
instance.data["label"] = geo_node.name()
@ -25,7 +25,7 @@ class CollectModel(pyblish.api.InstancePlugin):
handle_end = instance.context.data["handleEnd"]
first_frame = int(nuke.root()["first_frame"].getValue())
last_frame = int(nuke.root()["last_frame"].getValue())
families = [instance.data["productType"]] + instance.data["families"]
# Add version data to instance
version_data = {
"handleStart": handle_start,
@ -33,8 +33,8 @@ class CollectModel(pyblish.api.InstancePlugin):
"frameStart": first_frame + handle_start,
"frameEnd": last_frame - handle_end,
"colorspace": nuke.root().knob('workingSpaceLUT').value(),
"families": [instance.data["family"]] + instance.data["families"],
"subset": instance.data["subset"],
"families": families,
"productName": instance.data["productName"],
"fps": instance.context.data["fps"]
}

8
client/ayon_core/hosts/nuke/plugins/publish/collect_nuke_instance_data.py
View file

@ -12,10 +12,10 @@ class CollectInstanceData(pyblish.api.InstancePlugin):
hosts = ["nuke", "nukeassist"]
# presets
sync_workfile_version_on_product_types = []
sync_workfile_version_on_families = []
def process(self, instance):
family = instance.data["family"]
product_type = instance.data["productType"]
# Get format
root = nuke.root()
@ -25,10 +25,10 @@ class CollectInstanceData(pyblish.api.InstancePlugin):
pixel_aspect = format_.pixelAspect()
# sync workfile version
if family in self.sync_workfile_version_on_product_types:
if product_type in self.sync_workfile_version_on_families:
self.log.debug(
"Syncing version with workfile for '{}'".format(
family
product_type
)
)
# get version to instance for integration

4
client/ayon_core/hosts/nuke/plugins/publish/collect_reads.py
View file

@ -99,8 +99,8 @@ class CollectNukeReads(pyblish.api.InstancePlugin):
"frameStart": first_frame + handle_start,
"frameEnd": last_frame - handle_end,
"colorspace": colorspace,
"families": [instance.data["family"]],
"subset": instance.data["subset"],
"families": [instance.data["productType"]],
"productName": instance.data["productName"],
"fps": instance.context.data["fps"]
}

8
client/ayon_core/hosts/nuke/plugins/publish/collect_writes.py
View file

@ -138,14 +138,14 @@ class CollectNukeWrites(pyblish.api.InstancePlugin,
render_target (str): render target
colorspace (str): colorspace
"""
family = instance.data["family"]
product_type = instance.data["productType"]
# add targeted family to families
instance.data["families"].append(
"{}.{}".format(family, render_target)
"{}.{}".format(product_type, render_target)
)
self.log.debug("Appending render target to families: {}.{}".format(
family, render_target)
product_type, render_target)
)
write_node = self._write_node_helper(instance)
@ -175,7 +175,7 @@ class CollectNukeWrites(pyblish.api.InstancePlugin,
"colorspace": colorspace
})
if family == "render":
if product_type == "render":
instance.data.update({
"handleStart": handle_start,
"handleEnd": handle_end,

4
client/ayon_core/hosts/nuke/plugins/publish/extract_camera.py
View file

@ -38,7 +38,7 @@ class ExtractCamera(publish.Extractor):
rm_nodes = []
self.log.debug("Creating additional nodes for 3D Camera Extractor")
subset = instance.data["subset"]
product_name = instance.data["productName"]
staging_dir = self.staging_dir(instance)
# get extension form preset
@ -50,7 +50,7 @@ class ExtractCamera(publish.Extractor):
"Talk to your supervisor or pipeline admin")
# create file name and path
filename = subset + ".{}".format(extension)
filename = product_name + ".{}".format(extension)
file_path = os.path.join(staging_dir, filename).replace("\\", "/")
with maintained_selection():

4
client/ayon_core/hosts/nuke/plugins/publish/extract_model.py
View file

@ -40,7 +40,7 @@ class ExtractModel(publish.Extractor):
model_node = instance.data["transientData"]["node"]
self.log.debug("Creating additional nodes for Extract Model")
subset = instance.data["subset"]
product_name = instance.data["productName"]
staging_dir = self.staging_dir(instance)
extension = next((k[1] for k in self.write_geo_knobs
@ -51,7 +51,7 @@ class ExtractModel(publish.Extractor):
"Talk to your supervisor or pipeline admin")
# create file name and path
filename = subset + ".{}".format(extension)
filename = product_name + ".{}".format(extension)
file_path = os.path.join(staging_dir, filename).replace("\\", "/")
with maintained_selection():

28
client/ayon_core/hosts/nuke/plugins/publish/extract_render_local.py
View file

@ -38,7 +38,7 @@ class NukeRenderLocal(publish.Extractor,
self.log.debug("instance collected: {}".format(instance.data))
node_subset_name = instance.data.get("name", None)
node_product_name = instance.data.get("name", None)
first_frame = instance.data.get("frameStartHandle", None)
last_frame = instance.data.get("frameEndHandle", None)
@ -80,7 +80,7 @@ class NukeRenderLocal(publish.Extractor,
# Render frames
nuke.execute(
str(node_subset_name),
str(node_product_name),
int(render_first_frame),
int(render_last_frame)
)
@ -125,21 +125,25 @@ class NukeRenderLocal(publish.Extractor,
))
families = instance.data["families"]
anatomy_data = instance.data["anatomyData"]
# redefinition of families
if "render.local" in families:
instance.data['family'] = 'render'
families.remove('render.local')
instance.data["productType"] = "render"
families.remove("render.local")
families.insert(0, "render2d")
instance.data["anatomyData"]["family"] = "render"
anatomy_data["family"] = "render"
anatomy_data["product"]["type"] = "render"
elif "prerender.local" in families:
instance.data['family'] = 'prerender'
families.remove('prerender.local')
instance.data["productType"] = "prerender"
families.remove("prerender.local")
families.insert(0, "prerender")
instance.data["anatomyData"]["family"] = "prerender"
anatomy_data["family"] = "prerender"
anatomy_data["product"]["type"] = "prerender"
elif "image.local" in families:
instance.data['family'] = 'image'
families.remove('image.local')
instance.data["anatomyData"]["family"] = "image"
instance.data["productType"] = "image"
families.remove("image.local")
anatomy_data["family"] = "image"
anatomy_data["product"]["type"] = "image"
instance.data["families"] = families
collections, remainder = clique.assemble(filenames)
@ -160,7 +164,7 @@ class NukeRenderLocal(publish.Extractor,
These are base of files which will be extended/fixed for specific
frames.
Renames published file to expected file name based on frame, eg.
test_project_test_asset_subset_v005.1001.exr > new_render.1001.exr
test_project_test_asset_product_v005.1001.exr > new_render.1001.exr
"""
last_published = instance.data["last_version_published_files"]
last_published_and_frames = collect_frames(last_published)

2
client/ayon_core/hosts/nuke/plugins/publish/extract_review_intermediates.py
View file

@ -54,7 +54,7 @@ class ExtractReviewIntermediates(publish.Extractor):
families = set(instance.data["families"])
# add main family to make sure all families are compared
families.add(instance.data["family"])
families.add(instance.data["productType"])
task_type = instance.context.data["taskType"]
subset = instance.data["subset"]

2
client/ayon_core/hosts/nuke/plugins/publish/extract_slate_frame.py
View file

@ -115,7 +115,7 @@ class ExtractSlateFrame(publish.Extractor):
"""Slate frame renderer
Args:
instance (PyblishInstance): Pyblish instance with subset data
instance (PyblishInstance): Pyblish instance with product data
output_name (str, optional):
Slate variation name. Defaults to None.
bake_viewer_process (bool, optional):

8
client/ayon_core/hosts/nuke/plugins/publish/validate_exposed_knobs.py
View file

@ -29,7 +29,8 @@ class RepairExposedKnobs(pyblish.api.Action):
if x.Class() == "Write":
write_node = x
plugin_name = plugin.families_mapping[instance.data["family"]]
product_type = instance.data["productType"]
plugin_name = plugin.product_types_mapping[product_type]
nuke_settings = instance.context.data["project_settings"]["nuke"]
create_settings = nuke_settings["create"][plugin_name]
exposed_knobs = create_settings["exposed_knobs"]
@ -51,7 +52,7 @@ class ValidateExposedKnobs(
label = "Validate Exposed Knobs"
actions = [RepairExposedKnobs]
hosts = ["nuke"]
families_mapping = {
product_types_mapping = {
"render": "CreateWriteRender",
"prerender": "CreateWritePrerender",
"image": "CreateWriteImage"
@ -61,7 +62,8 @@ class ValidateExposedKnobs(
if not self.is_active(instance.data):
return
plugin = self.families_mapping[instance.data["family"]]
product_type = instance.data["productType"]
plugin = self.product_types_mapping[product_type]
group_node = instance.data["transientData"]["node"]
nuke_settings = instance.context.data["project_settings"]["nuke"]
create_settings = nuke_settings["create"][plugin]

2
client/ayon_core/hosts/nuke/plugins/publish/validate_knobs.py
View file

@ -67,7 +67,7 @@ class ValidateKnobs(pyblish.api.ContextPlugin):
settings_knobs = json.loads(cls.knobs)
# Filter families.
families = [instance.data["family"]]
families = [instance.data["productType"]]
families += instance.data.get("families", [])
# Get all knobs to validate.

7
client/ayon_core/hosts/nuke/startup/custom_write_node.py
View file

@ -111,9 +111,14 @@ class WriteNodeKnobSettingPanel(nukescripts.PythonPanel):
)
for write_node in write_selected_nodes:
# data for mapping the path
# TODO add more fill data
product_name = write_node["name"].value()
data = {
"work": os.getenv("AYON_WORKDIR"),
"subset": write_node["name"].value(),
"subset": product_name,
"product": {
"name": product_name,
},
"frame": "#" * frame_padding,
"ext": ext
}