diff --git a/.github/ISSUE_TEMPLATE/bug_report.yml b/.github/ISSUE_TEMPLATE/bug_report.yml
index 86e3638ffe..e2afcdaac7 100644
--- a/.github/ISSUE_TEMPLATE/bug_report.yml
+++ b/.github/ISSUE_TEMPLATE/bug_report.yml
@@ -35,6 +35,9 @@ body:
label: Version
description: What version are you running? Look to OpenPype Tray
options:
+ - 3.17.7-nightly.2
+ - 3.17.7-nightly.1
+ - 3.17.6
- 3.17.6-nightly.3
- 3.17.6-nightly.2
- 3.17.6-nightly.1
@@ -132,9 +135,6 @@ body:
- 3.15.2-nightly.5
- 3.15.2-nightly.4
- 3.15.2-nightly.3
- - 3.15.2-nightly.2
- - 3.15.2-nightly.1
- - 3.15.1
validations:
required: true
- type: dropdown
diff --git a/CHANGELOG.md b/CHANGELOG.md
index b3daf581ac..5909c26f7e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,386 @@
# Changelog
+## [3.17.6](https://github.com/ynput/OpenPype/tree/3.17.6)
+
+
+[Full Changelog](https://github.com/ynput/OpenPype/compare/3.17.5...3.17.6)
+
+### **🚀 Enhancements**
+
+
+
+Testing: Validate Maya Logs #5775
+
+This PR adds testing of the logs within Maya such as Python and Pyblish errors.The reason why we need to touch so many files outside of Maya is because of the pyblish errors below;
+```
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "collect_otio_frame_ranges" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "collect_otio_frame_ranges" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "collect_otio_review" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "collect_otio_review" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "collect_otio_subset_resources" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "collect_otio_subset_resources" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "extract_otio_audio_tracks" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "extract_otio_audio_tracks" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "extract_otio_file" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "extract_otio_file" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "extract_otio_review" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "extract_otio_review" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "extract_otio_trimming_video" (No module named 'opentimelineio')
+# Error: pyblish.plugin : Skipped: "extract_otio_trimming_video" (No module named 'opentimelineio') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "submit_blender_deadline" (No module named 'bpy')
+# Error: pyblish.plugin : Skipped: "submit_blender_deadline" (No module named 'bpy') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "submit_houdini_remote_publish" (No module named 'hou')
+# Error: pyblish.plugin : Skipped: "submit_houdini_remote_publish" (No module named 'hou') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "submit_houdini_render_deadline" (No module named 'hou')
+# Error: pyblish.plugin : Skipped: "submit_houdini_render_deadline" (No module named 'hou') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "submit_max_deadline" (No module named 'pymxs')
+# Error: pyblish.plugin : Skipped: "submit_max_deadline" (No module named 'pymxs') #
+pyblish (ERROR) (line: 1371) pyblish.plugin:
+Skipped: "submit_nuke_deadline" (No module named 'nuke')
+# Error: pyblish.plugin : Skipped: "submit_nuke_deadline" (No module named 'nuke') #
+```
+We also needed to `stdout` and `stderr` from the launched application to capture the output.Split from #5644.Dependent on #5734
+
+
+___
+
+
+
+
+
+Maya: Render Settings cleanup remove global `RENDER_ATTRS` #5801
+
+Remove global `lib.RENDER_ATTRS` and implement a `RenderSettings.get_padding_attr(renderer)` method instead.
+
+
+___
+
+
+
+
+
+Testing: Ingest expected files and input workfile #5840
+
+This ingests the Maya workfile from the Drive storage. Have changed the format to MayaAscii so its easier to see what changes are happening in a PR. This meant changing the expected files and database entries as well.
+
+
+___
+
+
+
+
+
+Chore: Create plugin auto-apply settings #5908
+
+Create plugins can auto-apply settings.
+
+
+___
+
+
+
+
+
+Resolve: Add save current file button + "Save" shortcut when menu is active #5691
+
+Adds a "Save current file" to the OpenPype menu.Also adds a "Save" shortcut key sequence (CTRL+S on Windows) to the button, so that clicking CTRL+S when the menu is active will save the current workfile. However this of course does not work if the menu does not receive the key press event (e.g. when Resolve UI is active instead)Resolves #5684
+
+
+___
+
+
+
+
+
+Reference USD file as maya native geometry #5781
+
+Add MayaUsdReferenceLoader to reference USD as Maya native geometry using `mayaUSDImport` file translator.
+
+
+___
+
+
+
+
+
+Max: Bug fix on wrong aspect ratio and viewport not being maximized during context in review family #5839
+
+This PR will fix the bug on wrong aspect ratio and viewport not being maximized when creating preview animationBesides, the support of tga image format and the options for AA quality are implemented in this PR
+
+
+___
+
+
+
+
+
+Blender: Incorporate blender "Collections" into Publish/Load #5841
+
+Allow `blendScene` family to include collections.
+
+
+___
+
+
+
+
+
+Max: Allows user preset the setting of preview animation in OP/AYON Setting #5859
+
+Allows user preset the setting of preview animation in OP/AYON Setting for review family.
+- [x] Openpype
+- [x] AYON
+
+
+___
+
+
+
+
+
+Publisher: Center publisher window on first show #5877
+
+Move publisher window to center of a screen on first show.
+
+
+___
+
+
+
+
+
+Publisher: Instance context changes confirm works #5881
+
+Confirmation of context changes in publisher on existing instances does not cause glitches.
+
+
+___
+
+
+
+
+
+AYON workfiles tools: Revisit workfiles tool #5897
+
+Revisited workfiles tool for AYON mode to reuse common models and widgets.
+
+
+___
+
+
+
+
+
+Nuke: updated colorspace settings #5906
+
+Updating nuke colorspace settings into more convenient way with usage of ocio config roles rather then particular colorspace names. This way we should not have troubles to switch between linear Rec709 or ACES configs without any additional settings changes.
+
+
+___
+
+
+
+
+
+Blender: Refactor to new publisher #5910
+
+Refactor Blender integration to use the new publisher
+
+
+___
+
+
+
+
+
+Enhancement: Some publish logs cosmetics #5917
+
+General logging message tweaks:
+- Sort some lists of folder/filenames so they appear sorted in the logs
+- Fix some grammar / typos
+- In some cases provide slightly more information in a log
+
+
+___
+
+
+
+
+
+Blender: Better name of 'asset_name' function #5927
+
+Renamed function `asset_name` to `prepare_scene_name`.
+
+
+___
+
+
+
+### **🐛 Bug fixes**
+
+
+
+Maya: Bug fix the fbx animation export errored out when the skeletonAnim set is empty #5875
+
+Resolve this bug discordIf the skeletonAnim SET is empty and fbx animation collect, the fbx animation extractor would skip the fbx extraction
+
+
+___
+
+
+
+
+
+Bugfix: fix few typos in houdini's and Maya's Ayon settings #5882
+
+Fixing few typos
+- [x] Maya unreal static mesh
+- [x] Houdini static mesh
+- [x] Houdini collect asset handles
+
+
+___
+
+
+
+
+
+Bugfix: Ayon Deadline env vars + error message on no executable found #5815
+
+Fix some Ayon x Deadline issues as came up in this topic:
+- missing Environment Variables issue explained here for `deadlinePlugin.RunProcess` for the AYON _extract environments_ call.
+- wrong error formatting described here with a `;` between each character like this: `Ayon executable was not found in the semicolon separated list "C;:;/;P;r;o;g;r;a;m; ;F;i;l;e;s;/;Y;n;p;u;t;/;A;Y;O;N; ;1;.;0;.;0;-;b;e;t;a;.;5;/;a;y;o;n;_;c;o;n;s;o;l;e;.;e;x;e". The path to the render executable can be configured from the Plugin Configuration in the Deadline Monitor.`
+
+
+___
+
+
+
+
+
+AYON: Fix bundles access in settings #5856
+
+Fixed access to bundles data in settings to define correct develop variant.
+
+
+___
+
+
+
+
+
+AYON 3dsMax settings: 'ValidateAttributes' settings converte only if available #5878
+
+Convert `ValidateAttributes` settings only if are available in AYON settings.
+
+
+___
+
+
+
+
+
+AYON: Fix TrayPublisher editorial settings #5880
+
+Fixing Traypublisher settings for adding task in simple editorial.
+
+
+___
+
+
+
+
+
+TrayPublisher: editorial frame range check not needed #5884
+
+Validator for frame ranges is not needed during editorial publishing since entity data are not yet in database.
+
+
+___
+
+
+
+
+
+Update houdini license validator #5886
+
+As reported in this community commentHoudini USD publishing is only restricted in Houdini apprentice.
+
+
+___
+
+
+
+
+
+Blender: Fix blend extraction and packed images #5888
+
+Fixed a with blend extractor and packed images.
+
+
+___
+
+
+
+
+
+AYON: Initialize connection with all information #5890
+
+Create global AYON api connection with all informations all the time.
+
+
+___
+
+
+
+
+
+AYON: Scene inventory tool without site sync #5896
+
+Skip 'get_site_icons' if site sync addon is disabled.
+
+
+___
+
+
+
+
+
+Publish report tool: Fix PySide6 #5898
+
+Use constants from classes instead of objects.
+
+
+___
+
+
+
+
+
+fusion: removing hardcoded template name for saver #5907
+
+Fusion is not hardcoded for `render` anatomy template only anymore. This was blocking AYON deployment.
+
+
+___
+
+
+
+
+
+
## [3.17.5](https://github.com/ynput/OpenPype/tree/3.17.5)
diff --git a/openpype/client/__init__.py b/openpype/client/__init__.py
index fe6dc97877..ba36d940e3 100644
--- a/openpype/client/__init__.py
+++ b/openpype/client/__init__.py
@@ -44,6 +44,8 @@ from .entities import (
get_thumbnail_id_from_source,
get_workfile_info,
+
+ get_asset_name_identifier,
)
from .entity_links import (
@@ -108,4 +110,6 @@ __all__ = (
"get_linked_representation_id",
"create_project",
+
+ "get_asset_name_identifier",
)
diff --git a/openpype/client/entities.py b/openpype/client/entities.py
index 5d9654c611..cbaa943743 100644
--- a/openpype/client/entities.py
+++ b/openpype/client/entities.py
@@ -4,3 +4,22 @@ if not AYON_SERVER_ENABLED:
from .mongo.entities import *
else:
from .server.entities import *
+
+
+def get_asset_name_identifier(asset_doc):
+ """Get asset name identifier by asset document.
+
+ This function is added because of AYON implementation where name
+ identifier is not just a name but full path.
+
+ Asset document must have "name" key, and "data.parents" when in AYON mode.
+
+ Args:
+ asset_doc (dict[str, Any]): Asset document.
+ """
+
+ if not AYON_SERVER_ENABLED:
+ return asset_doc["name"]
+ parents = list(asset_doc["data"]["parents"])
+ parents.append(asset_doc["name"])
+ return "/" + "/".join(parents)
diff --git a/openpype/client/server/conversion_utils.py b/openpype/client/server/conversion_utils.py
index 8c18cb1c13..51af99e722 100644
--- a/openpype/client/server/conversion_utils.py
+++ b/openpype/client/server/conversion_utils.py
@@ -138,16 +138,22 @@ def _template_replacements_to_v3(template):
)
-def _convert_template_item(template):
- # Others won't have 'directory'
- if "directory" not in template:
- return
- folder = _template_replacements_to_v3(template.pop("directory"))
- template["folder"] = folder
- template["file"] = _template_replacements_to_v3(template["file"])
- template["path"] = "/".join(
- (folder, template["file"])
- )
+def _convert_template_item(template_item):
+ for key, value in tuple(template_item.items()):
+ template_item[key] = _template_replacements_to_v3(value)
+
+ # Change 'directory' to 'folder'
+ if "directory" in template_item:
+ template_item["folder"] = template_item.pop("directory")
+
+ if (
+ "path" not in template_item
+ and "file" in template_item
+ and "folder" in template_item
+ ):
+ template_item["path"] = "/".join(
+ (template_item["folder"], template_item["file"])
+ )
def _fill_template_category(templates, cat_templates, cat_key):
@@ -212,10 +218,27 @@ def convert_v4_project_to_v3(project):
_convert_template_item(template)
new_others_templates[name] = template
+ staging_templates = templates.pop("staging", None)
+ # Key 'staging_directories' is legacy key that changed
+ # to 'staging_dir'
+ _legacy_staging_templates = templates.pop("staging_directories", None)
+ if staging_templates is None:
+ staging_templates = _legacy_staging_templates
+
+ if staging_templates is None:
+ staging_templates = {}
+
+ # Prefix all staging template names with 'staging_' prefix
+ # and add them to 'others'
+ for name, template in staging_templates.items():
+ _convert_template_item(template)
+ new_name = "staging_{}".format(name)
+ new_others_templates[new_name] = template
+
for key in (
"work",
"publish",
- "hero"
+ "hero",
):
cat_templates = templates.pop(key)
_fill_template_category(templates, cat_templates, key)
diff --git a/openpype/client/server/entities.py b/openpype/client/server/entities.py
index b41727a797..75e58703be 100644
--- a/openpype/client/server/entities.py
+++ b/openpype/client/server/entities.py
@@ -182,6 +182,19 @@ def get_asset_by_name(project_name, asset_name, fields=None):
return None
+def _folders_query(project_name, con, fields, **kwargs):
+ if fields is None or "tasks" in fields:
+ folders = get_folders_with_tasks(
+ con, project_name, fields=fields, **kwargs
+ )
+
+ else:
+ folders = con.get_folders(project_name, fields=fields, **kwargs)
+
+ for folder in folders:
+ yield folder
+
+
def get_assets(
project_name,
asset_ids=None,
@@ -201,20 +214,39 @@ def get_assets(
fields = folder_fields_v3_to_v4(fields, con)
kwargs = dict(
folder_ids=asset_ids,
- folder_names=asset_names,
parent_ids=parent_ids,
active=active,
- fields=fields
)
+ if not asset_names:
+ for folder in _folders_query(project_name, con, fields, **kwargs):
+ yield convert_v4_folder_to_v3(folder, project_name)
+ return
- if fields is None or "tasks" in fields:
- folders = get_folders_with_tasks(con, project_name, **kwargs)
+ new_asset_names = set()
+ folder_paths = set()
+ for name in asset_names:
+ if "/" in name:
+ folder_paths.add(name)
+ else:
+ new_asset_names.add(name)
- else:
- folders = con.get_folders(project_name, **kwargs)
+ yielded_ids = set()
+ if folder_paths:
+ for folder in _folders_query(
+ project_name, con, fields, folder_paths=folder_paths, **kwargs
+ ):
+ yielded_ids.add(folder["id"])
+ yield convert_v4_folder_to_v3(folder, project_name)
- for folder in folders:
- yield convert_v4_folder_to_v3(folder, project_name)
+ if not new_asset_names:
+ return
+
+ for folder in _folders_query(
+ project_name, con, fields, folder_names=new_asset_names, **kwargs
+ ):
+ if folder["id"] not in yielded_ids:
+ yielded_ids.add(folder["id"])
+ yield convert_v4_folder_to_v3(folder, project_name)
def get_archived_assets(
diff --git a/openpype/client/server/openpype_comp.py b/openpype/client/server/openpype_comp.py
index a123fe3167..71a141e913 100644
--- a/openpype/client/server/openpype_comp.py
+++ b/openpype/client/server/openpype_comp.py
@@ -1,4 +1,7 @@
import collections
+import json
+
+import six
from ayon_api.graphql import GraphQlQuery, FIELD_VALUE, fields_to_dict
from .constants import DEFAULT_FOLDER_FIELDS
@@ -84,12 +87,12 @@ def get_folders_with_tasks(
for folder. All possible folder fields are returned if 'None'
is passed.
- Returns:
- List[Dict[str, Any]]: Queried folder entities.
+ Yields:
+ Dict[str, Any]: Queried folder entities.
"""
if not project_name:
- return []
+ return
filters = {
"projectName": project_name
@@ -97,25 +100,25 @@ def get_folders_with_tasks(
if folder_ids is not None:
folder_ids = set(folder_ids)
if not folder_ids:
- return []
+ return
filters["folderIds"] = list(folder_ids)
if folder_paths is not None:
folder_paths = set(folder_paths)
if not folder_paths:
- return []
+ return
filters["folderPaths"] = list(folder_paths)
if folder_names is not None:
folder_names = set(folder_names)
if not folder_names:
- return []
+ return
filters["folderNames"] = list(folder_names)
if parent_ids is not None:
parent_ids = set(parent_ids)
if not parent_ids:
- return []
+ return
if None in parent_ids:
# Replace 'None' with '"root"' which is used during GraphQl
# query for parent ids filter for folders without folder
@@ -147,10 +150,10 @@ def get_folders_with_tasks(
parsed_data = query.query(con)
folders = parsed_data["project"]["folders"]
- if active is None:
- return folders
- return [
- folder
- for folder in folders
- if folder["active"] is active
- ]
+ for folder in folders:
+ if active is not None and folder["active"] is not active:
+ continue
+ folder_data = folder.get("data")
+ if isinstance(folder_data, six.string_types):
+ folder["data"] = json.loads(folder_data)
+ yield folder
diff --git a/openpype/host/host.py b/openpype/host/host.py
index 630fb873a8..afe06d1f55 100644
--- a/openpype/host/host.py
+++ b/openpype/host/host.py
@@ -170,7 +170,7 @@ class HostBase(object):
if project_name:
items.append(project_name)
if asset_name:
- items.append(asset_name)
+ items.append(asset_name.lstrip("/"))
if task_name:
items.append(task_name)
if items:
diff --git a/openpype/hosts/aftereffects/plugins/create/workfile_creator.py b/openpype/hosts/aftereffects/plugins/create/workfile_creator.py
index 2e7b9d4a7e..5dc3d6592d 100644
--- a/openpype/hosts/aftereffects/plugins/create/workfile_creator.py
+++ b/openpype/hosts/aftereffects/plugins/create/workfile_creator.py
@@ -1,3 +1,4 @@
+from openpype import AYON_SERVER_ENABLED
import openpype.hosts.aftereffects.api as api
from openpype.client import get_asset_by_name
from openpype.pipeline import (
@@ -43,6 +44,14 @@ class AEWorkfileCreator(AutoCreator):
task_name = context.get_current_task_name()
host_name = context.host_name
+ existing_asset_name = None
+ if existing_instance is not None:
+ if AYON_SERVER_ENABLED:
+ existing_asset_name = existing_instance.get("folderPath")
+
+ if existing_asset_name is None:
+ existing_asset_name = existing_instance["asset"]
+
if existing_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
@@ -50,10 +59,13 @@ class AEWorkfileCreator(AutoCreator):
project_name, host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": self.default_variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
data.update(self.get_dynamic_data(
self.default_variant, task_name, asset_doc,
project_name, host_name, None
@@ -68,7 +80,7 @@ class AEWorkfileCreator(AutoCreator):
new_instance.data_to_store())
elif (
- existing_instance["asset"] != asset_name
+ existing_asset_name != asset_name
or existing_instance["task"] != task_name
):
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -76,6 +88,10 @@ class AEWorkfileCreator(AutoCreator):
self.default_variant, task_name, asset_doc,
project_name, host_name
)
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
+
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/aftereffects/plugins/publish/collect_workfile.py b/openpype/hosts/aftereffects/plugins/publish/collect_workfile.py
index dc557f67fc..58d2757840 100644
--- a/openpype/hosts/aftereffects/plugins/publish/collect_workfile.py
+++ b/openpype/hosts/aftereffects/plugins/publish/collect_workfile.py
@@ -1,6 +1,8 @@
import os
import pyblish.api
+
+from openpype.client import get_asset_name_identifier
from openpype.pipeline.create import get_subset_name
@@ -48,9 +50,11 @@ class CollectWorkfile(pyblish.api.ContextPlugin):
asset_entity = context.data["assetEntity"]
project_entity = context.data["projectEntity"]
+ asset_name = get_asset_name_identifier(asset_entity)
+
instance_data = {
"active": True,
- "asset": asset_entity["name"],
+ "asset": asset_name,
"task": task,
"frameStart": context.data['frameStart'],
"frameEnd": context.data['frameEnd'],
diff --git a/openpype/hosts/blender/api/__init__.py b/openpype/hosts/blender/api/__init__.py
index e15f1193a5..ce2b444997 100644
--- a/openpype/hosts/blender/api/__init__.py
+++ b/openpype/hosts/blender/api/__init__.py
@@ -10,6 +10,7 @@ from .pipeline import (
ls,
publish,
containerise,
+ BlenderHost,
)
from .plugin import (
@@ -47,6 +48,7 @@ __all__ = [
"ls",
"publish",
"containerise",
+ "BlenderHost",
"Creator",
"Loader",
diff --git a/openpype/hosts/blender/api/lib.py b/openpype/hosts/blender/api/lib.py
index 1f68dd0839..e80ed61bc8 100644
--- a/openpype/hosts/blender/api/lib.py
+++ b/openpype/hosts/blender/api/lib.py
@@ -188,7 +188,7 @@ def imprint(node: bpy.types.bpy_struct_meta_idprop, data: Dict):
# Support values evaluated at imprint
value = value()
- if not isinstance(value, (int, float, bool, str, list)):
+ if not isinstance(value, (int, float, bool, str, list, dict)):
raise TypeError(f"Unsupported type: {type(value)}")
imprint_data[key] = value
@@ -278,9 +278,11 @@ def get_selected_collections():
list: A list of `bpy.types.Collection` objects that are currently
selected in the outliner.
"""
+ window = bpy.context.window or bpy.context.window_manager.windows[0]
+
try:
area = next(
- area for area in bpy.context.window.screen.areas
+ area for area in window.screen.areas
if area.type == 'OUTLINER')
region = next(
region for region in area.regions
@@ -290,10 +292,10 @@ def get_selected_collections():
"must be in the main Blender window.") from e
with bpy.context.temp_override(
- window=bpy.context.window,
+ window=window,
area=area,
region=region,
- screen=bpy.context.window.screen
+ screen=window.screen
):
ids = bpy.context.selected_ids
diff --git a/openpype/hosts/blender/api/ops.py b/openpype/hosts/blender/api/ops.py
index 208c11cfe8..f4d96e563a 100644
--- a/openpype/hosts/blender/api/ops.py
+++ b/openpype/hosts/blender/api/ops.py
@@ -31,6 +31,14 @@ PREVIEW_COLLECTIONS: Dict = dict()
TIMER_INTERVAL: float = 0.01 if platform.system() == "Windows" else 0.1
+def execute_function_in_main_thread(f):
+ """Decorator to move a function call into main thread items"""
+ def wrapper(*args, **kwargs):
+ mti = MainThreadItem(f, *args, **kwargs)
+ execute_in_main_thread(mti)
+ return wrapper
+
+
class BlenderApplication(QtWidgets.QApplication):
_instance = None
blender_windows = {}
@@ -238,8 +246,24 @@ class LaunchQtApp(bpy.types.Operator):
self.before_window_show()
+ def pull_to_front(window):
+ """Pull window forward to screen.
+
+ If Window is minimized this will un-minimize, then it can be raised
+ and activated to the front.
+ """
+ window.setWindowState(
+ (window.windowState() & ~QtCore.Qt.WindowMinimized) |
+ QtCore.Qt.WindowActive
+ )
+ window.raise_()
+ window.activateWindow()
+
if isinstance(self._window, ModuleType):
self._window.show()
+ pull_to_front(self._window)
+
+ # Pull window to the front
window = None
if hasattr(self._window, "window"):
window = self._window.window
@@ -254,6 +278,7 @@ class LaunchQtApp(bpy.types.Operator):
on_top_flags = origin_flags | QtCore.Qt.WindowStaysOnTopHint
self._window.setWindowFlags(on_top_flags)
self._window.show()
+ pull_to_front(self._window)
# if on_top_flags != origin_flags:
# self._window.setWindowFlags(origin_flags)
@@ -275,6 +300,10 @@ class LaunchCreator(LaunchQtApp):
def before_window_show(self):
self._window.refresh()
+ def execute(self, context):
+ host_tools.show_publisher(tab="create")
+ return {"FINISHED"}
+
class LaunchLoader(LaunchQtApp):
"""Launch Avalon Loader."""
@@ -299,7 +328,7 @@ class LaunchPublisher(LaunchQtApp):
bl_label = "Publish..."
def execute(self, context):
- host_tools.show_publish()
+ host_tools.show_publisher(tab="publish")
return {"FINISHED"}
@@ -416,7 +445,6 @@ class TOPBAR_MT_avalon(bpy.types.Menu):
layout.operator(SetResolution.bl_idname, text="Set Resolution")
layout.separator()
layout.operator(LaunchWorkFiles.bl_idname, text="Work Files...")
- # TODO (jasper): maybe add 'Reload Pipeline'
def draw_avalon_menu(self, context):
diff --git a/openpype/hosts/blender/api/pipeline.py b/openpype/hosts/blender/api/pipeline.py
index 84af0904f0..b386dd49d3 100644
--- a/openpype/hosts/blender/api/pipeline.py
+++ b/openpype/hosts/blender/api/pipeline.py
@@ -10,6 +10,12 @@ from . import ops
import pyblish.api
+from openpype.host import (
+ HostBase,
+ IWorkfileHost,
+ IPublishHost,
+ ILoadHost
+)
from openpype.client import get_asset_by_name
from openpype.pipeline import (
schema,
@@ -29,6 +35,14 @@ from openpype.lib import (
)
import openpype.hosts.blender
from openpype.settings import get_project_settings
+from .workio import (
+ open_file,
+ save_file,
+ current_file,
+ has_unsaved_changes,
+ file_extensions,
+ work_root,
+)
HOST_DIR = os.path.dirname(os.path.abspath(openpype.hosts.blender.__file__))
@@ -47,6 +61,101 @@ IS_HEADLESS = bpy.app.background
log = Logger.get_logger(__name__)
+class BlenderHost(HostBase, IWorkfileHost, IPublishHost, ILoadHost):
+ name = "blender"
+
+ def install(self):
+ """Override install method from HostBase.
+ Install Blender host functionality."""
+ install()
+
+ def get_containers(self) -> Iterator:
+ """List containers from active Blender scene."""
+ return ls()
+
+ def get_workfile_extensions(self) -> List[str]:
+ """Override get_workfile_extensions method from IWorkfileHost.
+ Get workfile possible extensions.
+
+ Returns:
+ List[str]: Workfile extensions.
+ """
+ return file_extensions()
+
+ def save_workfile(self, dst_path: str = None):
+ """Override save_workfile method from IWorkfileHost.
+ Save currently opened workfile.
+
+ Args:
+ dst_path (str): Where the current scene should be saved. Or use
+ current path if `None` is passed.
+ """
+ save_file(dst_path if dst_path else bpy.data.filepath)
+
+ def open_workfile(self, filepath: str):
+ """Override open_workfile method from IWorkfileHost.
+ Open workfile at specified filepath in the host.
+
+ Args:
+ filepath (str): Path to workfile.
+ """
+ open_file(filepath)
+
+ def get_current_workfile(self) -> str:
+ """Override get_current_workfile method from IWorkfileHost.
+ Retrieve currently opened workfile path.
+
+ Returns:
+ str: Path to currently opened workfile.
+ """
+ return current_file()
+
+ def workfile_has_unsaved_changes(self) -> bool:
+ """Override wokfile_has_unsaved_changes method from IWorkfileHost.
+ Returns True if opened workfile has no unsaved changes.
+
+ Returns:
+ bool: True if scene is saved and False if it has unsaved
+ modifications.
+ """
+ return has_unsaved_changes()
+
+ def work_root(self, session) -> str:
+ """Override work_root method from IWorkfileHost.
+ Modify workdir per host.
+
+ Args:
+ session (dict): Session context data.
+
+ Returns:
+ str: Path to new workdir.
+ """
+ return work_root(session)
+
+ def get_context_data(self) -> dict:
+ """Override abstract method from IPublishHost.
+ Get global data related to creation-publishing from workfile.
+
+ Returns:
+ dict: Context data stored using 'update_context_data'.
+ """
+ property = bpy.context.scene.get(AVALON_PROPERTY)
+ if property:
+ return property.to_dict()
+ return {}
+
+ def update_context_data(self, data: dict, changes: dict):
+ """Override abstract method from IPublishHost.
+ Store global context data to workfile.
+
+ Args:
+ data (dict): New data as are.
+ changes (dict): Only data that has been changed. Each value has
+ tuple with '(, )' value.
+ """
+ bpy.context.scene[AVALON_PROPERTY] = data
+
+
def pype_excepthook_handler(*args):
traceback.print_exception(*args)
diff --git a/openpype/hosts/blender/api/plugin.py b/openpype/hosts/blender/api/plugin.py
index 2f940011ba..568d8f6695 100644
--- a/openpype/hosts/blender/api/plugin.py
+++ b/openpype/hosts/blender/api/plugin.py
@@ -1,31 +1,34 @@
"""Shared functionality for pipeline plugins for Blender."""
+import itertools
from pathlib import Path
from typing import Dict, List, Optional
import bpy
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline import (
- LegacyCreator,
+ Creator,
+ CreatedInstance,
LoaderPlugin,
)
+from openpype.lib import BoolDef
+
from .pipeline import (
AVALON_CONTAINERS,
+ AVALON_INSTANCES,
AVALON_PROPERTY,
)
from .ops import (
MainThreadItem,
execute_in_main_thread
)
-from .lib import (
- imprint,
- get_selection
-)
+from .lib import imprint
VALID_EXTENSIONS = [".blend", ".json", ".abc", ".fbx"]
-def asset_name(
+def prepare_scene_name(
asset: str, subset: str, namespace: Optional[str] = None
) -> str:
"""Return a consistent name for an asset."""
@@ -144,20 +147,224 @@ def deselect_all():
bpy.context.view_layer.objects.active = active
-class Creator(LegacyCreator):
- """Base class for Creator plug-ins."""
+class BaseCreator(Creator):
+ """Base class for Blender Creator plug-ins."""
defaults = ['Main']
- def process(self):
- collection = bpy.data.collections.new(name=self.data["subset"])
- bpy.context.scene.collection.children.link(collection)
- imprint(collection, self.data)
+ create_as_asset_group = False
- if (self.options or {}).get("useSelection"):
- for obj in get_selection():
- collection.objects.link(obj)
+ @staticmethod
+ def cache_subsets(shared_data):
+ """Cache instances for Creators shared data.
- return collection
+ Create `blender_cached_subsets` key when needed in shared data and
+ fill it with all collected instances from the scene under its
+ respective creator identifiers.
+
+ If legacy instances are detected in the scene, create
+ `blender_cached_legacy_subsets` key and fill it with
+ all legacy subsets from this family as a value. # key or value?
+
+ Args:
+ shared_data(Dict[str, Any]): Shared data.
+
+ Return:
+ Dict[str, Any]: Shared data with cached subsets.
+ """
+ if not shared_data.get('blender_cached_subsets'):
+ cache = {}
+ cache_legacy = {}
+
+ avalon_instances = bpy.data.collections.get(AVALON_INSTANCES)
+ avalon_instance_objs = (
+ avalon_instances.objects if avalon_instances else []
+ )
+
+ for obj_or_col in itertools.chain(
+ avalon_instance_objs,
+ bpy.data.collections
+ ):
+ avalon_prop = obj_or_col.get(AVALON_PROPERTY, {})
+ if not avalon_prop:
+ continue
+
+ if avalon_prop.get('id') != 'pyblish.avalon.instance':
+ continue
+
+ creator_id = avalon_prop.get('creator_identifier')
+ if creator_id:
+ # Creator instance
+ cache.setdefault(creator_id, []).append(obj_or_col)
+ else:
+ family = avalon_prop.get('family')
+ if family:
+ # Legacy creator instance
+ cache_legacy.setdefault(family, []).append(obj_or_col)
+
+ shared_data["blender_cached_subsets"] = cache
+ shared_data["blender_cached_legacy_subsets"] = cache_legacy
+
+ return shared_data
+
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ """Override abstract method from Creator.
+ Create new instance and store it.
+
+ Args:
+ subset_name(str): Subset name of created instance.
+ instance_data(dict): Instance base data.
+ pre_create_data(dict): Data based on pre creation attributes.
+ Those may affect how creator works.
+ """
+ # Get Instance Container or create it if it does not exist
+ instances = bpy.data.collections.get(AVALON_INSTANCES)
+ if not instances:
+ instances = bpy.data.collections.new(name=AVALON_INSTANCES)
+ bpy.context.scene.collection.children.link(instances)
+
+ # Create asset group
+ if AYON_SERVER_ENABLED:
+ asset_name = instance_data["folderPath"]
+ else:
+ asset_name = instance_data["asset"]
+
+ name = prepare_scene_name(asset_name, subset_name)
+ if self.create_as_asset_group:
+ # Create instance as empty
+ instance_node = bpy.data.objects.new(name=name, object_data=None)
+ instance_node.empty_display_type = 'SINGLE_ARROW'
+ instances.objects.link(instance_node)
+ else:
+ # Create instance collection
+ instance_node = bpy.data.collections.new(name=name)
+ instances.children.link(instance_node)
+
+ self.set_instance_data(subset_name, instance_data)
+
+ instance = CreatedInstance(
+ self.family, subset_name, instance_data, self
+ )
+ instance.transient_data["instance_node"] = instance_node
+ self._add_instance_to_context(instance)
+
+ imprint(instance_node, instance_data)
+
+ return instance_node
+
+ def collect_instances(self):
+ """Override abstract method from BaseCreator.
+ Collect existing instances related to this creator plugin."""
+
+ # Cache subsets in shared data
+ self.cache_subsets(self.collection_shared_data)
+
+ # Get cached subsets
+ cached_subsets = self.collection_shared_data.get(
+ "blender_cached_subsets"
+ )
+ if not cached_subsets:
+ return
+
+ # Process only instances that were created by this creator
+ for instance_node in cached_subsets.get(self.identifier, []):
+ property = instance_node.get(AVALON_PROPERTY)
+ # Create instance object from existing data
+ instance = CreatedInstance.from_existing(
+ instance_data=property.to_dict(),
+ creator=self
+ )
+ instance.transient_data["instance_node"] = instance_node
+
+ # Add instance to create context
+ self._add_instance_to_context(instance)
+
+ def update_instances(self, update_list):
+ """Override abstract method from BaseCreator.
+ Store changes of existing instances so they can be recollected.
+
+ Args:
+ update_list(List[UpdateData]): Changed instances
+ and their changes, as a list of tuples.
+ """
+
+ if AYON_SERVER_ENABLED:
+ asset_name_key = "folderPath"
+ else:
+ asset_name_key = "asset"
+
+ for created_instance, changes in update_list:
+ data = created_instance.data_to_store()
+ node = created_instance.transient_data["instance_node"]
+ if not node:
+ # We can't update if we don't know the node
+ self.log.error(
+ f"Unable to update instance {created_instance} "
+ f"without instance node."
+ )
+ return
+
+ # Rename the instance node in the scene if subset or asset changed
+ if (
+ "subset" in changes.changed_keys
+ or asset_name_key in changes.changed_keys
+ ):
+ asset_name = data[asset_name_key]
+ name = prepare_scene_name(
+ asset=asset_name, subset=data["subset"]
+ )
+ node.name = name
+
+ imprint(node, data)
+
+ def remove_instances(self, instances: List[CreatedInstance]):
+
+ for instance in instances:
+ node = instance.transient_data["instance_node"]
+
+ if isinstance(node, bpy.types.Collection):
+ for children in node.children_recursive:
+ if isinstance(children, bpy.types.Collection):
+ bpy.data.collections.remove(children)
+ else:
+ bpy.data.objects.remove(children)
+
+ bpy.data.collections.remove(node)
+ elif isinstance(node, bpy.types.Object):
+ bpy.data.objects.remove(node)
+
+ self._remove_instance_from_context(instance)
+
+ def set_instance_data(
+ self,
+ subset_name: str,
+ instance_data: dict
+ ):
+ """Fill instance data with required items.
+
+ Args:
+ subset_name(str): Subset name of created instance.
+ instance_data(dict): Instance base data.
+ instance_node(bpy.types.ID): Instance node in blender scene.
+ """
+ if not instance_data:
+ instance_data = {}
+
+ instance_data.update(
+ {
+ "id": "pyblish.avalon.instance",
+ "creator_identifier": self.identifier,
+ "subset": subset_name,
+ }
+ )
+
+ def get_pre_create_attr_defs(self):
+ return [
+ BoolDef("use_selection",
+ label="Use selection",
+ default=True)
+ ]
class Loader(LoaderPlugin):
@@ -251,7 +458,7 @@ class AssetLoader(LoaderPlugin):
namespace: Use pre-defined namespace
options: Additional settings dictionary
"""
- # TODO (jasper): make it possible to add the asset several times by
+ # TODO: make it possible to add the asset several times by
# just re-using the collection
filepath = self.filepath_from_context(context)
assert Path(filepath).exists(), f"{filepath} doesn't exist."
@@ -262,7 +469,7 @@ class AssetLoader(LoaderPlugin):
asset, subset
)
namespace = namespace or f"{asset}_{unique_number}"
- name = name or asset_name(
+ name = name or prepare_scene_name(
asset, subset, unique_number
)
@@ -291,7 +498,9 @@ class AssetLoader(LoaderPlugin):
# asset = context["asset"]["name"]
# subset = context["subset"]["name"]
- # instance_name = asset_name(asset, subset, unique_number) + '_CON'
+ # instance_name = prepare_scene_name(
+ # asset, subset, unique_number
+ # ) + '_CON'
# return self._get_instance_collection(instance_name, nodes)
diff --git a/openpype/hosts/blender/blender_addon/startup/init.py b/openpype/hosts/blender/blender_addon/startup/init.py
index 8dbff8a91d..603691675d 100644
--- a/openpype/hosts/blender/blender_addon/startup/init.py
+++ b/openpype/hosts/blender/blender_addon/startup/init.py
@@ -1,9 +1,9 @@
from openpype.pipeline import install_host
-from openpype.hosts.blender import api
+from openpype.hosts.blender.api import BlenderHost
def register():
- install_host(api)
+ install_host(BlenderHost())
def unregister():
diff --git a/openpype/hosts/blender/plugins/create/convert_legacy.py b/openpype/hosts/blender/plugins/create/convert_legacy.py
new file mode 100644
index 0000000000..f05a6b1f5a
--- /dev/null
+++ b/openpype/hosts/blender/plugins/create/convert_legacy.py
@@ -0,0 +1,78 @@
+# -*- coding: utf-8 -*-
+"""Converter for legacy Houdini subsets."""
+from openpype.pipeline.create.creator_plugins import SubsetConvertorPlugin
+from openpype.hosts.blender.api.lib import imprint
+
+
+class BlenderLegacyConvertor(SubsetConvertorPlugin):
+ """Find and convert any legacy subsets in the scene.
+
+ This Converter will find all legacy subsets in the scene and will
+ transform them to the current system. Since the old subsets doesn't
+ retain any information about their original creators, the only mapping
+ we can do is based on their families.
+
+ Its limitation is that you can have multiple creators creating subset
+ of the same family and there is no way to handle it. This code should
+ nevertheless cover all creators that came with OpenPype.
+
+ """
+ identifier = "io.openpype.creators.blender.legacy"
+ family_to_id = {
+ "action": "io.openpype.creators.blender.action",
+ "camera": "io.openpype.creators.blender.camera",
+ "animation": "io.openpype.creators.blender.animation",
+ "blendScene": "io.openpype.creators.blender.blendscene",
+ "layout": "io.openpype.creators.blender.layout",
+ "model": "io.openpype.creators.blender.model",
+ "pointcache": "io.openpype.creators.blender.pointcache",
+ "render": "io.openpype.creators.blender.render",
+ "review": "io.openpype.creators.blender.review",
+ "rig": "io.openpype.creators.blender.rig",
+ }
+
+ def __init__(self, *args, **kwargs):
+ super(BlenderLegacyConvertor, self).__init__(*args, **kwargs)
+ self.legacy_subsets = {}
+
+ def find_instances(self):
+ """Find legacy subsets in the scene.
+
+ Legacy subsets are the ones that doesn't have `creator_identifier`
+ parameter on them.
+
+ This is using cached entries done in
+ :py:meth:`~BaseCreator.cache_subsets()`
+
+ """
+ self.legacy_subsets = self.collection_shared_data.get(
+ "blender_cached_legacy_subsets")
+ if not self.legacy_subsets:
+ return
+ self.add_convertor_item(
+ "Found {} incompatible subset{}".format(
+ len(self.legacy_subsets),
+ "s" if len(self.legacy_subsets) > 1 else ""
+ )
+ )
+
+ def convert(self):
+ """Convert all legacy subsets to current.
+
+ It is enough to add `creator_identifier` and `instance_node`.
+
+ """
+ if not self.legacy_subsets:
+ return
+
+ for family, instance_nodes in self.legacy_subsets.items():
+ if family in self.family_to_id:
+ for instance_node in instance_nodes:
+ creator_identifier = self.family_to_id[family]
+ self.log.info(
+ "Converting {} to {}".format(instance_node.name,
+ creator_identifier)
+ )
+ imprint(instance_node, data={
+ "creator_identifier": creator_identifier
+ })
diff --git a/openpype/hosts/blender/plugins/create/create_action.py b/openpype/hosts/blender/plugins/create/create_action.py
index 0203ba74c0..caaa72fe8d 100644
--- a/openpype/hosts/blender/plugins/create/create_action.py
+++ b/openpype/hosts/blender/plugins/create/create_action.py
@@ -2,30 +2,29 @@
import bpy
-from openpype.pipeline import get_current_task_name
-import openpype.hosts.blender.api.plugin
-from openpype.hosts.blender.api import lib
+from openpype.hosts.blender.api import lib, plugin
-class CreateAction(openpype.hosts.blender.api.plugin.Creator):
- """Action output for character rigs"""
+class CreateAction(plugin.BaseCreator):
+ """Action output for character rigs."""
- name = "actionMain"
+ identifier = "io.openpype.creators.blender.action"
label = "Action"
family = "action"
icon = "male"
- def process(self):
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ # Run parent create method
+ collection = super().create(
+ subset_name, instance_data, pre_create_data
+ )
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
- collection = bpy.data.collections.new(name=name)
- bpy.context.scene.collection.children.link(collection)
- self.data['task'] = get_current_task_name()
- lib.imprint(collection, self.data)
+ # Get instance name
+ name = plugin.prepare_scene_name(instance_data["asset"], subset_name)
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
for obj in lib.get_selection():
if (obj.animation_data is not None
and obj.animation_data.action is not None):
diff --git a/openpype/hosts/blender/plugins/create/create_animation.py b/openpype/hosts/blender/plugins/create/create_animation.py
index bc2840952b..3a91b2d5ff 100644
--- a/openpype/hosts/blender/plugins/create/create_animation.py
+++ b/openpype/hosts/blender/plugins/create/create_animation.py
@@ -1,51 +1,32 @@
"""Create an animation asset."""
-import bpy
-
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreateAnimation(plugin.Creator):
- """Animation output for character rigs"""
+class CreateAnimation(plugin.BaseCreator):
+ """Animation output for character rigs."""
- name = "animationMain"
+ identifier = "io.openpype.creators.blender.animation"
label = "Animation"
family = "animation"
icon = "male"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ # Run parent create method
+ collection = super().create(
+ subset_name, instance_data, pre_create_data
+ )
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
-
- # Create instance object
- # name = self.name
- # if not name:
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- # asset_group = bpy.data.objects.new(name=name, object_data=None)
- # asset_group.empty_display_type = 'SINGLE_ARROW'
- asset_group = bpy.data.collections.new(name=name)
- instances.children.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
-
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
selected = lib.get_selection()
for obj in selected:
- asset_group.objects.link(obj)
- elif (self.options or {}).get("asset_group"):
- obj = (self.options or {}).get("asset_group")
- asset_group.objects.link(obj)
+ collection.objects.link(obj)
+ elif pre_create_data.get("asset_group"):
+ # Use for Load Blend automated creation of animation instances
+ # upon loading rig files
+ obj = pre_create_data.get("asset_group")
+ collection.objects.link(obj)
- return asset_group
+ return collection
diff --git a/openpype/hosts/blender/plugins/create/create_blendScene.py b/openpype/hosts/blender/plugins/create/create_blendScene.py
index bb57a16888..e1026282c0 100644
--- a/openpype/hosts/blender/plugins/create/create_blendScene.py
+++ b/openpype/hosts/blender/plugins/create/create_blendScene.py
@@ -2,51 +2,33 @@
import bpy
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreateBlendScene(plugin.Creator):
- """Generic group of assets"""
+class CreateBlendScene(plugin.BaseCreator):
+ """Generic group of assets."""
- name = "blendScene"
+ identifier = "io.openpype.creators.blender.blendscene"
label = "Blender Scene"
family = "blendScene"
icon = "cubes"
maintain_selection = False
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
+ instance_node = super().create(subset_name,
+ instance_data,
+ pre_create_data)
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
-
- # Create the new asset group as collection
- asset_group = bpy.data.collections.new(name=name)
- instances.children.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
-
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
selection = lib.get_selection(include_collections=True)
-
for data in selection:
if isinstance(data, bpy.types.Collection):
- asset_group.children.link(data)
+ instance_node.children.link(data)
elif isinstance(data, bpy.types.Object):
- asset_group.objects.link(data)
+ instance_node.objects.link(data)
- return asset_group
+ return instance_node
diff --git a/openpype/hosts/blender/plugins/create/create_camera.py b/openpype/hosts/blender/plugins/create/create_camera.py
index 7a770a3e77..2e2e6cec22 100644
--- a/openpype/hosts/blender/plugins/create/create_camera.py
+++ b/openpype/hosts/blender/plugins/create/create_camera.py
@@ -2,62 +2,41 @@
import bpy
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
+from openpype.hosts.blender.api import plugin, lib
from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
-class CreateCamera(plugin.Creator):
- """Polygonal static geometry"""
+class CreateCamera(plugin.BaseCreator):
+ """Polygonal static geometry."""
- name = "cameraMain"
+ identifier = "io.openpype.creators.blender.camera"
label = "Camera"
family = "camera"
icon = "video-camera"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ create_as_asset_group = True
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
+ asset_group = super().create(subset_name,
+ instance_data,
+ pre_create_data)
- asset_group = bpy.data.objects.new(name=name, object_data=None)
- asset_group.empty_display_type = 'SINGLE_ARROW'
- instances.objects.link(asset_group)
- self.data['task'] = get_current_task_name()
- print(f"self.data: {self.data}")
- lib.imprint(asset_group, self.data)
-
- if (self.options or {}).get("useSelection"):
- bpy.context.view_layer.objects.active = asset_group
- selected = lib.get_selection()
- for obj in selected:
- if obj.parent in selected:
- obj.select_set(False)
- continue
- selected.append(asset_group)
- bpy.ops.object.parent_set(keep_transform=True)
+ bpy.context.view_layer.objects.active = asset_group
+ if pre_create_data.get("use_selection"):
+ for obj in lib.get_selection():
+ obj.parent = asset_group
else:
plugin.deselect_all()
- camera = bpy.data.cameras.new(subset)
- camera_obj = bpy.data.objects.new(subset, camera)
+ camera = bpy.data.cameras.new(subset_name)
+ camera_obj = bpy.data.objects.new(subset_name, camera)
+ instances = bpy.data.collections.get(AVALON_INSTANCES)
instances.objects.link(camera_obj)
- camera_obj.select_set(True)
- asset_group.select_set(True)
bpy.context.view_layer.objects.active = asset_group
- bpy.ops.object.parent_set(keep_transform=True)
+ camera_obj.parent = asset_group
return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_layout.py b/openpype/hosts/blender/plugins/create/create_layout.py
index 73ed683256..16d227e50e 100644
--- a/openpype/hosts/blender/plugins/create/create_layout.py
+++ b/openpype/hosts/blender/plugins/create/create_layout.py
@@ -2,50 +2,31 @@
import bpy
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreateLayout(plugin.Creator):
- """Layout output for character rigs"""
+class CreateLayout(plugin.BaseCreator):
+ """Layout output for character rigs."""
- name = "layoutMain"
+ identifier = "io.openpype.creators.blender.layout"
label = "Layout"
family = "layout"
icon = "cubes"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ create_as_asset_group = True
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- asset_group = bpy.data.objects.new(name=name, object_data=None)
- asset_group.empty_display_type = 'SINGLE_ARROW'
- instances.objects.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
+ asset_group = super().create(subset_name,
+ instance_data,
+ pre_create_data)
# Add selected objects to instance
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
bpy.context.view_layer.objects.active = asset_group
- selected = lib.get_selection()
- for obj in selected:
- if obj.parent in selected:
- obj.select_set(False)
- continue
- selected.append(asset_group)
- bpy.ops.object.parent_set(keep_transform=True)
+ for obj in lib.get_selection():
+ obj.parent = asset_group
return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_model.py b/openpype/hosts/blender/plugins/create/create_model.py
index 51fc6683f6..2f3f61728b 100644
--- a/openpype/hosts/blender/plugins/create/create_model.py
+++ b/openpype/hosts/blender/plugins/create/create_model.py
@@ -2,50 +2,30 @@
import bpy
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreateModel(plugin.Creator):
- """Polygonal static geometry"""
+class CreateModel(plugin.BaseCreator):
+ """Polygonal static geometry."""
- name = "modelMain"
+ identifier = "io.openpype.creators.blender.model"
label = "Model"
family = "model"
icon = "cube"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ create_as_asset_group = True
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
-
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- asset_group = bpy.data.objects.new(name=name, object_data=None)
- asset_group.empty_display_type = 'SINGLE_ARROW'
- instances.objects.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ asset_group = super().create(subset_name,
+ instance_data,
+ pre_create_data)
# Add selected objects to instance
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
bpy.context.view_layer.objects.active = asset_group
- selected = lib.get_selection()
- for obj in selected:
- if obj.parent in selected:
- obj.select_set(False)
- continue
- selected.append(asset_group)
- bpy.ops.object.parent_set(keep_transform=True)
+ for obj in lib.get_selection():
+ obj.parent = asset_group
return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_pointcache.py b/openpype/hosts/blender/plugins/create/create_pointcache.py
index 65cf18472d..b3329bcb3b 100644
--- a/openpype/hosts/blender/plugins/create/create_pointcache.py
+++ b/openpype/hosts/blender/plugins/create/create_pointcache.py
@@ -1,51 +1,29 @@
"""Create a pointcache asset."""
-import bpy
-
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreatePointcache(plugin.Creator):
- """Polygonal static geometry"""
+class CreatePointcache(plugin.BaseCreator):
+ """Polygonal static geometry."""
- name = "pointcacheMain"
+ identifier = "io.openpype.creators.blender.pointcache"
label = "Point Cache"
family = "pointcache"
icon = "gears"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ # Run parent create method
+ collection = super().create(
+ subset_name, instance_data, pre_create_data
+ )
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
+ if pre_create_data.get("use_selection"):
+ objects = lib.get_selection()
+ for obj in objects:
+ collection.objects.link(obj)
+ if obj.type == 'EMPTY':
+ objects.extend(obj.children)
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- asset_group = bpy.data.objects.new(name=name, object_data=None)
- asset_group.empty_display_type = 'SINGLE_ARROW'
- instances.objects.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
-
- # Add selected objects to instance
- if (self.options or {}).get("useSelection"):
- bpy.context.view_layer.objects.active = asset_group
- selected = lib.get_selection()
- for obj in selected:
- if obj.parent in selected:
- obj.select_set(False)
- continue
- selected.append(asset_group)
- bpy.ops.object.parent_set(keep_transform=True)
-
- return asset_group
+ return collection
diff --git a/openpype/hosts/blender/plugins/create/create_render.py b/openpype/hosts/blender/plugins/create/create_render.py
index f938a21808..7fb3e5eb00 100644
--- a/openpype/hosts/blender/plugins/create/create_render.py
+++ b/openpype/hosts/blender/plugins/create/create_render.py
@@ -1,42 +1,31 @@
"""Create render."""
import bpy
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib
+from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.render_lib import prepare_rendering
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
-class CreateRenderlayer(plugin.Creator):
- """Single baked camera"""
+class CreateRenderlayer(plugin.BaseCreator):
+ """Single baked camera."""
- name = "renderingMain"
+ identifier = "io.openpype.creators.blender.render"
label = "Render"
family = "render"
icon = "eye"
- def process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
-
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- asset_group = bpy.data.collections.new(name=name)
-
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
try:
- instances.children.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
+ # Run parent create method
+ collection = super().create(
+ subset_name, instance_data, pre_create_data
+ )
- prepare_rendering(asset_group)
+ prepare_rendering(collection)
except Exception:
# Remove the instance if there was an error
- bpy.data.collections.remove(asset_group)
+ bpy.data.collections.remove(collection)
raise
# TODO: this is undesiderable, but it's the only way to be sure that
@@ -50,4 +39,4 @@ class CreateRenderlayer(plugin.Creator):
# now it is to force the file to be saved.
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
- return asset_group
+ return collection
diff --git a/openpype/hosts/blender/plugins/create/create_review.py b/openpype/hosts/blender/plugins/create/create_review.py
index 914f249891..940bcbea22 100644
--- a/openpype/hosts/blender/plugins/create/create_review.py
+++ b/openpype/hosts/blender/plugins/create/create_review.py
@@ -1,47 +1,27 @@
"""Create review."""
-import bpy
-
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreateReview(plugin.Creator):
- """Single baked camera"""
+class CreateReview(plugin.BaseCreator):
+ """Single baked camera."""
- name = "reviewDefault"
+ identifier = "io.openpype.creators.blender.review"
label = "Review"
family = "review"
icon = "video-camera"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ # Run parent create method
+ collection = super().create(
+ subset_name, instance_data, pre_create_data
+ )
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
-
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- asset_group = bpy.data.collections.new(name=name)
- instances.children.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
-
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
selected = lib.get_selection()
for obj in selected:
- asset_group.objects.link(obj)
- elif (self.options or {}).get("asset_group"):
- obj = (self.options or {}).get("asset_group")
- asset_group.objects.link(obj)
+ collection.objects.link(obj)
- return asset_group
+ return collection
diff --git a/openpype/hosts/blender/plugins/create/create_rig.py b/openpype/hosts/blender/plugins/create/create_rig.py
index 08cc46ee3e..d63b8d56ff 100644
--- a/openpype/hosts/blender/plugins/create/create_rig.py
+++ b/openpype/hosts/blender/plugins/create/create_rig.py
@@ -2,50 +2,30 @@
import bpy
-from openpype.pipeline import get_current_task_name
-from openpype.hosts.blender.api import plugin, lib, ops
-from openpype.hosts.blender.api.pipeline import AVALON_INSTANCES
+from openpype.hosts.blender.api import plugin, lib
-class CreateRig(plugin.Creator):
- """Artist-friendly rig with controls to direct motion"""
+class CreateRig(plugin.BaseCreator):
+ """Artist-friendly rig with controls to direct motion."""
- name = "rigMain"
+ identifier = "io.openpype.creators.blender.rig"
label = "Rig"
family = "rig"
icon = "wheelchair"
- def process(self):
- """ Run the creator on Blender main thread"""
- mti = ops.MainThreadItem(self._process)
- ops.execute_in_main_thread(mti)
+ create_as_asset_group = True
- def _process(self):
- # Get Instance Container or create it if it does not exist
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- if not instances:
- instances = bpy.data.collections.new(name=AVALON_INSTANCES)
- bpy.context.scene.collection.children.link(instances)
-
- # Create instance object
- asset = self.data["asset"]
- subset = self.data["subset"]
- name = plugin.asset_name(asset, subset)
- asset_group = bpy.data.objects.new(name=name, object_data=None)
- asset_group.empty_display_type = 'SINGLE_ARROW'
- instances.objects.link(asset_group)
- self.data['task'] = get_current_task_name()
- lib.imprint(asset_group, self.data)
+ def create(
+ self, subset_name: str, instance_data: dict, pre_create_data: dict
+ ):
+ asset_group = super().create(subset_name,
+ instance_data,
+ pre_create_data)
# Add selected objects to instance
- if (self.options or {}).get("useSelection"):
+ if pre_create_data.get("use_selection"):
bpy.context.view_layer.objects.active = asset_group
- selected = lib.get_selection()
- for obj in selected:
- if obj.parent in selected:
- obj.select_set(False)
- continue
- selected.append(asset_group)
- bpy.ops.object.parent_set(keep_transform=True)
+ for obj in lib.get_selection():
+ obj.parent = asset_group
return asset_group
diff --git a/openpype/hosts/blender/plugins/create/create_workfile.py b/openpype/hosts/blender/plugins/create/create_workfile.py
new file mode 100644
index 0000000000..ceec3e0552
--- /dev/null
+++ b/openpype/hosts/blender/plugins/create/create_workfile.py
@@ -0,0 +1,121 @@
+import bpy
+
+from openpype import AYON_SERVER_ENABLED
+from openpype.pipeline import CreatedInstance, AutoCreator
+from openpype.client import get_asset_by_name
+from openpype.hosts.blender.api.plugin import BaseCreator
+from openpype.hosts.blender.api.pipeline import (
+ AVALON_PROPERTY,
+ AVALON_CONTAINERS
+)
+
+
+class CreateWorkfile(BaseCreator, AutoCreator):
+ """Workfile auto-creator.
+
+ The workfile instance stores its data on the `AVALON_CONTAINERS` collection
+ as custom attributes, because unlike other instances it doesn't have an
+ instance node of its own.
+
+ """
+ identifier = "io.openpype.creators.blender.workfile"
+ label = "Workfile"
+ family = "workfile"
+ icon = "fa5.file"
+
+ def create(self):
+ """Create workfile instances."""
+ existing_instance = next(
+ (
+ instance for instance in self.create_context.instances
+ if instance.creator_identifier == self.identifier
+ ),
+ None,
+ )
+
+ project_name = self.project_name
+ asset_name = self.create_context.get_current_asset_name()
+ task_name = self.create_context.get_current_task_name()
+ host_name = self.create_context.host_name
+
+ existing_asset_name = None
+ if existing_instance is not None:
+ if AYON_SERVER_ENABLED:
+ existing_asset_name = existing_instance.get("folderPath")
+
+ if existing_asset_name is None:
+ existing_asset_name = existing_instance["asset"]
+
+ if not existing_instance:
+ asset_doc = get_asset_by_name(project_name, asset_name)
+ subset_name = self.get_subset_name(
+ task_name, task_name, asset_doc, project_name, host_name
+ )
+ data = {
+ "task": task_name,
+ "variant": task_name,
+ }
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
+ data.update(
+ self.get_dynamic_data(
+ task_name,
+ task_name,
+ asset_doc,
+ project_name,
+ host_name,
+ existing_instance,
+ )
+ )
+ self.log.info("Auto-creating workfile instance...")
+ current_instance = CreatedInstance(
+ self.family, subset_name, data, self
+ )
+ instance_node = bpy.data.collections.get(AVALON_CONTAINERS, {})
+ current_instance.transient_data["instance_node"] = instance_node
+ self._add_instance_to_context(current_instance)
+ elif (
+ existing_asset_name != asset_name
+ or existing_instance["task"] != task_name
+ ):
+ # Update instance context if it's different
+ asset_doc = get_asset_by_name(project_name, asset_name)
+ subset_name = self.get_subset_name(
+ task_name, task_name, asset_doc, project_name, host_name
+ )
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
+
+ existing_instance["task"] = task_name
+ existing_instance["subset"] = subset_name
+
+ def collect_instances(self):
+
+ instance_node = bpy.data.collections.get(AVALON_CONTAINERS)
+ if not instance_node:
+ return
+
+ property = instance_node.get(AVALON_PROPERTY)
+ if not property:
+ return
+
+ # Create instance object from existing data
+ instance = CreatedInstance.from_existing(
+ instance_data=property.to_dict(),
+ creator=self
+ )
+ instance.transient_data["instance_node"] = instance_node
+
+ # Add instance to create context
+ self._add_instance_to_context(instance)
+
+ def remove_instances(self, instances):
+ for instance in instances:
+ node = instance.transient_data["instance_node"]
+ del node[AVALON_PROPERTY]
+
+ self._remove_instance_from_context(instance)
diff --git a/openpype/hosts/blender/plugins/load/import_workfile.py b/openpype/hosts/blender/plugins/load/import_workfile.py
index 4f5016d422..331f6a8bdb 100644
--- a/openpype/hosts/blender/plugins/load/import_workfile.py
+++ b/openpype/hosts/blender/plugins/load/import_workfile.py
@@ -7,7 +7,7 @@ def append_workfile(context, fname, do_import):
asset = context['asset']['name']
subset = context['subset']['name']
- group_name = plugin.asset_name(asset, subset)
+ group_name = plugin.prepare_scene_name(asset, subset)
# We need to preserve the original names of the scenes, otherwise,
# if there are duplicate names in the current workfile, the imported
diff --git a/openpype/hosts/blender/plugins/load/load_abc.py b/openpype/hosts/blender/plugins/load/load_abc.py
index 8d1863d4d5..d7e82d1900 100644
--- a/openpype/hosts/blender/plugins/load/load_abc.py
+++ b/openpype/hosts/blender/plugins/load/load_abc.py
@@ -137,9 +137,9 @@ class CacheModelLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
containers = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_action.py b/openpype/hosts/blender/plugins/load/load_action.py
index 3447e67ebf..f7d32f92a5 100644
--- a/openpype/hosts/blender/plugins/load/load_action.py
+++ b/openpype/hosts/blender/plugins/load/load_action.py
@@ -7,7 +7,7 @@ from typing import Dict, List, Optional
import bpy
from openpype.pipeline import get_representation_path
-import openpype.hosts.blender.api.plugin
+from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.pipeline import (
containerise_existing,
AVALON_PROPERTY,
@@ -16,7 +16,7 @@ from openpype.hosts.blender.api.pipeline import (
logger = logging.getLogger("openpype").getChild("blender").getChild("load_action")
-class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
+class BlendActionLoader(plugin.AssetLoader):
"""Load action from a .blend file.
Warning:
@@ -46,8 +46,8 @@ class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
libpath = self.filepath_from_context(context)
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- lib_container = openpype.hosts.blender.api.plugin.asset_name(asset, subset)
- container_name = openpype.hosts.blender.api.plugin.asset_name(
+ lib_container = plugin.prepare_scene_name(asset, subset)
+ container_name = plugin.prepare_scene_name(
asset, subset, namespace
)
@@ -152,7 +152,7 @@ class BlendActionLoader(openpype.hosts.blender.api.plugin.AssetLoader):
assert libpath.is_file(), (
f"The file doesn't exist: {libpath}"
)
- assert extension in openpype.hosts.blender.api.plugin.VALID_EXTENSIONS, (
+ assert extension in plugin.VALID_EXTENSIONS, (
f"Unsupported file: {libpath}"
)
diff --git a/openpype/hosts/blender/plugins/load/load_audio.py b/openpype/hosts/blender/plugins/load/load_audio.py
index ac8f363316..1e5bd39a32 100644
--- a/openpype/hosts/blender/plugins/load/load_audio.py
+++ b/openpype/hosts/blender/plugins/load/load_audio.py
@@ -42,9 +42,9 @@ class AudioLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_blend.py b/openpype/hosts/blender/plugins/load/load_blend.py
index f7bbc630de..f437e66795 100644
--- a/openpype/hosts/blender/plugins/load/load_blend.py
+++ b/openpype/hosts/blender/plugins/load/load_blend.py
@@ -4,11 +4,11 @@ from pathlib import Path
import bpy
from openpype.pipeline import (
- legacy_create,
get_representation_path,
AVALON_CONTAINER_ID,
+ registered_host
)
-from openpype.pipeline.create import get_legacy_creator_by_name
+from openpype.pipeline.create import CreateContext
from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.lib import imprint
from openpype.hosts.blender.api.pipeline import (
@@ -57,19 +57,21 @@ class BlendLoader(plugin.AssetLoader):
obj.get(AVALON_PROPERTY).get('family') == 'rig'
)
]
+ if not rigs:
+ return
+
+ # Create animation instances for each rig
+ creator_identifier = "io.openpype.creators.blender.animation"
+ host = registered_host()
+ create_context = CreateContext(host)
for rig in rigs:
- creator_plugin = get_legacy_creator_by_name("CreateAnimation")
- legacy_create(
- creator_plugin,
- name=rig.name.split(':')[-1] + "_animation",
- asset=asset,
- options={
- "useSelection": False,
+ create_context.create(
+ creator_identifier=creator_identifier,
+ variant=rig.name.split(':')[-1],
+ pre_create_data={
+ "use_selection": False,
"asset_group": rig
- },
- data={
- "dependencies": representation
}
)
@@ -90,7 +92,6 @@ class BlendLoader(plugin.AssetLoader):
members.append(data)
container = self._get_asset_container(data_to.objects)
- print(container)
assert container, "No asset group found"
container.name = group_name
@@ -104,8 +105,6 @@ class BlendLoader(plugin.AssetLoader):
print(obj)
bpy.context.scene.collection.objects.link(obj)
- print("")
-
# Remove the library from the blend file
library = bpy.data.libraries.get(bpy.path.basename(libpath))
bpy.data.libraries.remove(library)
@@ -134,9 +133,9 @@ class BlendLoader(plugin.AssetLoader):
representation = str(context["representation"]["_id"])
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_blendscene.py b/openpype/hosts/blender/plugins/load/load_blendscene.py
index 2c955af9e8..6cc7f39d03 100644
--- a/openpype/hosts/blender/plugins/load/load_blendscene.py
+++ b/openpype/hosts/blender/plugins/load/load_blendscene.py
@@ -85,9 +85,9 @@ class BlendSceneLoader(plugin.AssetLoader):
except ValueError:
family = "model"
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_camera_abc.py b/openpype/hosts/blender/plugins/load/load_camera_abc.py
index 05d3fb764d..ecd6bb98f1 100644
--- a/openpype/hosts/blender/plugins/load/load_camera_abc.py
+++ b/openpype/hosts/blender/plugins/load/load_camera_abc.py
@@ -87,9 +87,9 @@ class AbcCameraLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_camera_fbx.py b/openpype/hosts/blender/plugins/load/load_camera_fbx.py
index 3cca6e7fd3..2d53d3e573 100644
--- a/openpype/hosts/blender/plugins/load/load_camera_fbx.py
+++ b/openpype/hosts/blender/plugins/load/load_camera_fbx.py
@@ -90,9 +90,9 @@ class FbxCameraLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_fbx.py b/openpype/hosts/blender/plugins/load/load_fbx.py
index e129ea6754..8fce53a5d5 100644
--- a/openpype/hosts/blender/plugins/load/load_fbx.py
+++ b/openpype/hosts/blender/plugins/load/load_fbx.py
@@ -134,9 +134,9 @@ class FbxModelLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_layout_json.py b/openpype/hosts/blender/plugins/load/load_layout_json.py
index 81683b8de8..748ac619b6 100644
--- a/openpype/hosts/blender/plugins/load/load_layout_json.py
+++ b/openpype/hosts/blender/plugins/load/load_layout_json.py
@@ -123,6 +123,7 @@ class JsonLayoutLoader(plugin.AssetLoader):
# raise ValueError("Creator plugin \"CreateCamera\" was "
# "not found.")
+ # TODO: Refactor legacy create usage to new style creators
# legacy_create(
# creator_plugin,
# name="camera",
@@ -148,9 +149,9 @@ class JsonLayoutLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- asset_name = plugin.asset_name(asset, subset)
+ asset_name = plugin.prepare_scene_name(asset, subset)
unique_number = plugin.get_unique_number(asset, subset)
- group_name = plugin.asset_name(asset, subset, unique_number)
+ group_name = plugin.prepare_scene_name(asset, subset, unique_number)
namespace = namespace or f"{asset}_{unique_number}"
avalon_container = bpy.data.collections.get(AVALON_CONTAINERS)
diff --git a/openpype/hosts/blender/plugins/load/load_look.py b/openpype/hosts/blender/plugins/load/load_look.py
index c121f55633..8d3118d83b 100644
--- a/openpype/hosts/blender/plugins/load/load_look.py
+++ b/openpype/hosts/blender/plugins/load/load_look.py
@@ -96,14 +96,14 @@ class BlendLookLoader(plugin.AssetLoader):
asset = context["asset"]["name"]
subset = context["subset"]["name"]
- lib_container = plugin.asset_name(
+ lib_container = plugin.prepare_scene_name(
asset, subset
)
unique_number = plugin.get_unique_number(
asset, subset
)
namespace = namespace or f"{asset}_{unique_number}"
- container_name = plugin.asset_name(
+ container_name = plugin.prepare_scene_name(
asset, subset, unique_number
)
diff --git a/openpype/hosts/blender/plugins/publish/collect_current_file.py b/openpype/hosts/blender/plugins/publish/collect_current_file.py
index c2d8a96a18..91c88f2e28 100644
--- a/openpype/hosts/blender/plugins/publish/collect_current_file.py
+++ b/openpype/hosts/blender/plugins/publish/collect_current_file.py
@@ -1,72 +1,15 @@
-import os
-import bpy
-
import pyblish.api
-from openpype.pipeline import get_current_task_name, get_current_asset_name
from openpype.hosts.blender.api import workio
-class SaveWorkfiledAction(pyblish.api.Action):
- """Save Workfile."""
- label = "Save Workfile"
- on = "failed"
- icon = "save"
-
- def process(self, context, plugin):
- bpy.ops.wm.avalon_workfiles()
-
-
class CollectBlenderCurrentFile(pyblish.api.ContextPlugin):
"""Inject the current working file into context"""
order = pyblish.api.CollectorOrder - 0.5
label = "Blender Current File"
hosts = ["blender"]
- actions = [SaveWorkfiledAction]
def process(self, context):
"""Inject the current working file"""
current_file = workio.current_file()
-
context.data["currentFile"] = current_file
-
- assert current_file, (
- "Current file is empty. Save the file before continuing."
- )
-
- folder, file = os.path.split(current_file)
- filename, ext = os.path.splitext(file)
-
- task = get_current_task_name()
-
- data = {}
-
- # create instance
- instance = context.create_instance(name=filename)
- subset = "workfile" + task.capitalize()
-
- data.update({
- "subset": subset,
- "asset": get_current_asset_name(),
- "label": subset,
- "publish": True,
- "family": "workfile",
- "families": ["workfile"],
- "setMembers": [current_file],
- "frameStart": bpy.context.scene.frame_start,
- "frameEnd": bpy.context.scene.frame_end,
- })
-
- data["representations"] = [{
- "name": ext.lstrip("."),
- "ext": ext.lstrip("."),
- "files": file,
- "stagingDir": folder,
- }]
-
- instance.data.update(data)
-
- self.log.info("Collected instance: {}".format(file))
- self.log.info("Scene path: {}".format(current_file))
- self.log.info("staging Dir: {}".format(folder))
- self.log.info("subset: {}".format(subset))
diff --git a/openpype/hosts/blender/plugins/publish/collect_instance.py b/openpype/hosts/blender/plugins/publish/collect_instance.py
new file mode 100644
index 0000000000..4685472213
--- /dev/null
+++ b/openpype/hosts/blender/plugins/publish/collect_instance.py
@@ -0,0 +1,43 @@
+import bpy
+
+import pyblish.api
+
+from openpype.pipeline.publish import KnownPublishError
+from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
+
+
+class CollectBlenderInstanceData(pyblish.api.InstancePlugin):
+ """Validator to verify that the instance is not empty"""
+
+ order = pyblish.api.CollectorOrder
+ hosts = ["blender"]
+ families = ["model", "pointcache", "animation", "rig", "camera", "layout",
+ "blendScene"]
+ label = "Collect Instance"
+
+ def process(self, instance):
+ instance_node = instance.data["transientData"]["instance_node"]
+
+ # Collect members of the instance
+ members = [instance_node]
+ if isinstance(instance_node, bpy.types.Collection):
+ members.extend(instance_node.objects)
+ members.extend(instance_node.children)
+
+ # Special case for animation instances, include armatures
+ if instance.data["family"] == "animation":
+ for obj in instance_node.objects:
+ if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
+ members.extend(
+ child for child in obj.children
+ if child.type == 'ARMATURE'
+ )
+ elif isinstance(instance_node, bpy.types.Object):
+ members.extend(instance_node.children_recursive)
+ else:
+ raise KnownPublishError(
+ f"Unsupported instance node type '{type(instance_node)}' "
+ f"for instance '{instance}'"
+ )
+
+ instance[:] = members
diff --git a/openpype/hosts/blender/plugins/publish/collect_instances.py b/openpype/hosts/blender/plugins/publish/collect_instances.py
deleted file mode 100644
index 2d56e5fd7b..0000000000
--- a/openpype/hosts/blender/plugins/publish/collect_instances.py
+++ /dev/null
@@ -1,70 +0,0 @@
-from typing import Generator
-
-import bpy
-
-import pyblish.api
-from openpype.hosts.blender.api.pipeline import (
- AVALON_INSTANCES,
- AVALON_PROPERTY,
-)
-
-
-class CollectInstances(pyblish.api.ContextPlugin):
- """Collect the data of a model."""
-
- hosts = ["blender"]
- label = "Collect Instances"
- order = pyblish.api.CollectorOrder
-
- @staticmethod
- def get_asset_groups() -> Generator:
- """Return all instances that are empty objects asset groups.
- """
- instances = bpy.data.collections.get(AVALON_INSTANCES)
- for obj in list(instances.objects) + list(instances.children):
- avalon_prop = obj.get(AVALON_PROPERTY) or {}
- if avalon_prop.get('id') == 'pyblish.avalon.instance':
- yield obj
-
- @staticmethod
- def create_instance(context, group):
- avalon_prop = group[AVALON_PROPERTY]
- asset = avalon_prop['asset']
- family = avalon_prop['family']
- subset = avalon_prop['subset']
- task = avalon_prop['task']
- name = f"{asset}_{subset}"
- return context.create_instance(
- name=name,
- family=family,
- families=[family],
- subset=subset,
- asset=asset,
- task=task,
- )
-
- def process(self, context):
- """Collect the models from the current Blender scene."""
- asset_groups = self.get_asset_groups()
-
- for group in asset_groups:
- instance = self.create_instance(context, group)
- instance.data["instance_group"] = group
- members = []
- if isinstance(group, bpy.types.Collection):
- members = list(group.objects)
- family = instance.data["family"]
- if family == "animation":
- for obj in group.objects:
- if obj.type == 'EMPTY' and obj.get(AVALON_PROPERTY):
- members.extend(
- child for child in obj.children
- if child.type == 'ARMATURE')
- else:
- members = group.children_recursive
-
- members.append(group)
- instance[:] = members
- self.log.debug(instance.data)
- for obj in instance:
- self.log.debug(obj)
diff --git a/openpype/hosts/blender/plugins/publish/collect_render.py b/openpype/hosts/blender/plugins/publish/collect_render.py
index 92e2473a95..00faf85aed 100644
--- a/openpype/hosts/blender/plugins/publish/collect_render.py
+++ b/openpype/hosts/blender/plugins/publish/collect_render.py
@@ -73,11 +73,12 @@ class CollectBlenderRender(pyblish.api.InstancePlugin):
def process(self, instance):
context = instance.context
- render_data = bpy.data.collections[str(instance)].get("render_data")
+ instance_node = instance.data["transientData"]["instance_node"]
+ render_data = instance_node.get("render_data")
assert render_data, "No render data found."
- self.log.info(f"render_data: {dict(render_data)}")
+ self.log.debug(f"render_data: {dict(render_data)}")
render_product = render_data.get("render_product")
aov_file_product = render_data.get("aov_file_product")
@@ -120,4 +121,4 @@ class CollectBlenderRender(pyblish.api.InstancePlugin):
"renderProducts": colorspace.ARenderProduct(),
})
- self.log.info(f"data: {instance.data}")
+ self.log.debug(f"data: {instance.data}")
diff --git a/openpype/hosts/blender/plugins/publish/collect_review.py b/openpype/hosts/blender/plugins/publish/collect_review.py
index 2760ab9811..2c077398da 100644
--- a/openpype/hosts/blender/plugins/publish/collect_review.py
+++ b/openpype/hosts/blender/plugins/publish/collect_review.py
@@ -16,10 +16,12 @@ class CollectReview(pyblish.api.InstancePlugin):
self.log.debug(f"instance: {instance}")
+ datablock = instance.data["transientData"]["instance_node"]
+
# get cameras
cameras = [
obj
- for obj in instance
+ for obj in datablock.all_objects
if isinstance(obj, bpy.types.Object) and obj.type == "CAMERA"
]
diff --git a/openpype/hosts/blender/plugins/publish/collect_workfile.py b/openpype/hosts/blender/plugins/publish/collect_workfile.py
new file mode 100644
index 0000000000..6561c89605
--- /dev/null
+++ b/openpype/hosts/blender/plugins/publish/collect_workfile.py
@@ -0,0 +1,37 @@
+from pathlib import Path
+
+from pyblish.api import InstancePlugin, CollectorOrder
+
+
+class CollectWorkfile(InstancePlugin):
+ """Inject workfile data into its instance."""
+
+ order = CollectorOrder
+ label = "Collect Workfile"
+ hosts = ["blender"]
+ families = ["workfile"]
+
+ def process(self, instance):
+ """Process collector."""
+
+ context = instance.context
+ filepath = Path(context.data["currentFile"])
+ ext = filepath.suffix
+
+ instance.data.update(
+ {
+ "setMembers": [filepath.as_posix()],
+ "frameStart": context.data.get("frameStart", 1),
+ "frameEnd": context.data.get("frameEnd", 1),
+ "handleStart": context.data.get("handleStart", 1),
+ "handledEnd": context.data.get("handleEnd", 1),
+ "representations": [
+ {
+ "name": ext.lstrip("."),
+ "ext": ext.lstrip("."),
+ "files": filepath.name,
+ "stagingDir": filepath.parent,
+ }
+ ],
+ }
+ )
diff --git a/openpype/hosts/blender/plugins/publish/extract_abc.py b/openpype/hosts/blender/plugins/publish/extract_abc.py
index b17d7cc6e4..0e242e9d53 100644
--- a/openpype/hosts/blender/plugins/publish/extract_abc.py
+++ b/openpype/hosts/blender/plugins/publish/extract_abc.py
@@ -4,10 +4,9 @@ import bpy
from openpype.pipeline import publish
from openpype.hosts.blender.api import plugin
-from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
-class ExtractABC(publish.Extractor):
+class ExtractABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""Extract as ABC."""
label = "Extract ABC"
@@ -15,9 +14,15 @@ class ExtractABC(publish.Extractor):
families = ["pointcache"]
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.abc"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.abc"
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -25,18 +30,16 @@ class ExtractABC(publish.Extractor):
plugin.deselect_all()
- selected = []
- active = None
+ asset_group = instance.data["transientData"]["instance_node"]
+ selected = []
for obj in instance:
- obj.select_set(True)
- selected.append(obj)
- # Set as active the asset group
- if obj.get(AVALON_PROPERTY):
- active = obj
+ if isinstance(obj, bpy.types.Object):
+ obj.select_set(True)
+ selected.append(obj)
context = plugin.create_blender_context(
- active=active, selected=selected)
+ active=asset_group, selected=selected)
with bpy.context.temp_override(**context):
# We export the abc
@@ -59,8 +62,8 @@ class ExtractABC(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
class ExtractModelABC(ExtractABC):
diff --git a/openpype/hosts/blender/plugins/publish/extract_abc_animation.py b/openpype/hosts/blender/plugins/publish/extract_abc_animation.py
index 6866b05fea..6ef9b29693 100644
--- a/openpype/hosts/blender/plugins/publish/extract_abc_animation.py
+++ b/openpype/hosts/blender/plugins/publish/extract_abc_animation.py
@@ -6,7 +6,10 @@ from openpype.pipeline import publish
from openpype.hosts.blender.api import plugin
-class ExtractAnimationABC(publish.Extractor):
+class ExtractAnimationABC(
+ publish.Extractor,
+ publish.OptionalPyblishPluginMixin,
+):
"""Extract as ABC."""
label = "Extract Animation ABC"
@@ -15,9 +18,16 @@ class ExtractAnimationABC(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.abc"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.abc"
+
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -26,7 +36,7 @@ class ExtractAnimationABC(publish.Extractor):
plugin.deselect_all()
selected = []
- asset_group = None
+ asset_group = instance.data["transientData"]["instance_node"]
objects = []
for obj in instance:
@@ -66,5 +76,5 @@ class ExtractAnimationABC(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_blend.py b/openpype/hosts/blender/plugins/publish/extract_blend.py
index 17e574c1be..94e87d537c 100644
--- a/openpype/hosts/blender/plugins/publish/extract_blend.py
+++ b/openpype/hosts/blender/plugins/publish/extract_blend.py
@@ -5,7 +5,7 @@ import bpy
from openpype.pipeline import publish
-class ExtractBlend(publish.Extractor):
+class ExtractBlend(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""Extract a blend file."""
label = "Extract Blend"
@@ -14,10 +14,16 @@ class ExtractBlend(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.blend"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.blend"
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -60,5 +66,5 @@ class ExtractBlend(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_blend_animation.py b/openpype/hosts/blender/plugins/publish/extract_blend_animation.py
index 661cecce81..11eb268271 100644
--- a/openpype/hosts/blender/plugins/publish/extract_blend_animation.py
+++ b/openpype/hosts/blender/plugins/publish/extract_blend_animation.py
@@ -5,7 +5,10 @@ import bpy
from openpype.pipeline import publish
-class ExtractBlendAnimation(publish.Extractor):
+class ExtractBlendAnimation(
+ publish.Extractor,
+ publish.OptionalPyblishPluginMixin,
+):
"""Extract a blend file."""
label = "Extract Blend"
@@ -14,10 +17,16 @@ class ExtractBlendAnimation(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.blend"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.blend"
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -50,5 +59,5 @@ class ExtractBlendAnimation(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_camera_abc.py b/openpype/hosts/blender/plugins/publish/extract_camera_abc.py
index 5916564ac0..df68668eae 100644
--- a/openpype/hosts/blender/plugins/publish/extract_camera_abc.py
+++ b/openpype/hosts/blender/plugins/publish/extract_camera_abc.py
@@ -7,7 +7,7 @@ from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
-class ExtractCameraABC(publish.Extractor):
+class ExtractCameraABC(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""Extract camera as ABC."""
label = "Extract Camera (ABC)"
@@ -16,9 +16,15 @@ class ExtractCameraABC(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.abc"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.abc"
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -26,12 +32,7 @@ class ExtractCameraABC(publish.Extractor):
plugin.deselect_all()
- asset_group = None
- for obj in instance:
- if obj.get(AVALON_PROPERTY):
- asset_group = obj
- break
- assert asset_group, "No asset group found"
+ asset_group = instance.data["transientData"]["instance_node"]
# Need to cast to list because children is a tuple
selected = list(asset_group.children)
@@ -64,5 +65,5 @@ class ExtractCameraABC(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py b/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py
index a541f5b375..ee046b7d11 100644
--- a/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py
+++ b/openpype/hosts/blender/plugins/publish/extract_camera_fbx.py
@@ -6,7 +6,7 @@ from openpype.pipeline import publish
from openpype.hosts.blender.api import plugin
-class ExtractCamera(publish.Extractor):
+class ExtractCamera(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""Extract as the camera as FBX."""
label = "Extract Camera (FBX)"
@@ -15,9 +15,15 @@ class ExtractCamera(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.fbx"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.fbx"
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -73,5 +79,5 @@ class ExtractCamera(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_fbx.py b/openpype/hosts/blender/plugins/publish/extract_fbx.py
index f2ce117dcd..4ae6501f7d 100644
--- a/openpype/hosts/blender/plugins/publish/extract_fbx.py
+++ b/openpype/hosts/blender/plugins/publish/extract_fbx.py
@@ -7,7 +7,7 @@ from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
-class ExtractFBX(publish.Extractor):
+class ExtractFBX(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""Extract as FBX."""
label = "Extract FBX"
@@ -16,9 +16,15 @@ class ExtractFBX(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
- filename = f"{instance.name}.fbx"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ filename = f"{instance_name}.fbx"
filepath = os.path.join(stagingdir, filename)
# Perform extraction
@@ -26,14 +32,12 @@ class ExtractFBX(publish.Extractor):
plugin.deselect_all()
- selected = []
- asset_group = None
+ asset_group = instance.data["transientData"]["instance_node"]
+ selected = []
for obj in instance:
obj.select_set(True)
selected.append(obj)
- if obj.get(AVALON_PROPERTY):
- asset_group = obj
context = plugin.create_blender_context(
active=asset_group, selected=selected)
@@ -84,5 +88,5 @@ class ExtractFBX(publish.Extractor):
}
instance.data["representations"].append(representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py b/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py
index 5fe5931e65..4fc8230a1b 100644
--- a/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py
+++ b/openpype/hosts/blender/plugins/publish/extract_fbx_animation.py
@@ -10,7 +10,41 @@ from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
-class ExtractAnimationFBX(publish.Extractor):
+def get_all_parents(obj):
+ """Get all recursive parents of object"""
+ result = []
+ while True:
+ obj = obj.parent
+ if not obj:
+ break
+ result.append(obj)
+ return result
+
+
+def get_highest_root(objects):
+ # Get the highest object that is also in the collection
+ included_objects = {obj.name_full for obj in objects}
+ num_parents_to_obj = {}
+ for obj in objects:
+ if isinstance(obj, bpy.types.Object):
+ parents = get_all_parents(obj)
+ # included parents
+ parents = [parent for parent in parents if
+ parent.name_full in included_objects]
+ if not parents:
+ # A node without parents must be a highest root
+ return obj
+
+ num_parents_to_obj.setdefault(len(parents), obj)
+
+ minimum_parent = min(num_parents_to_obj)
+ return num_parents_to_obj[minimum_parent]
+
+
+class ExtractAnimationFBX(
+ publish.Extractor,
+ publish.OptionalPyblishPluginMixin,
+):
"""Extract as animation."""
label = "Extract FBX"
@@ -19,23 +53,43 @@ class ExtractAnimationFBX(publish.Extractor):
optional = True
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
# Perform extraction
self.log.debug("Performing extraction..")
- # The first collection object in the instance is taken, as there
- # should be only one that contains the asset group.
- collection = [
- obj for obj in instance if type(obj) is bpy.types.Collection][0]
+ asset_group = instance.data["transientData"]["instance_node"]
- # Again, the first object in the collection is taken , as there
- # should be only the asset group in the collection.
- asset_group = collection.objects[0]
+ # Get objects in this collection (but not in children collections)
+ # and for those objects include the children hierarchy
+ # TODO: Would it make more sense for the Collect Instance collector
+ # to also always retrieve all the children?
+ objects = set(asset_group.objects)
- armature = [
- obj for obj in asset_group.children if obj.type == 'ARMATURE'][0]
+ # From the direct children of the collection find the 'root' node
+ # that we want to export - it is the 'highest' node in a hierarchy
+ root = get_highest_root(objects)
+
+ for obj in list(objects):
+ objects.update(obj.children_recursive)
+
+ # Find all armatures among the objects, assume to find only one
+ armatures = [obj for obj in objects if obj.type == "ARMATURE"]
+ if not armatures:
+ raise RuntimeError(
+ f"Unable to find ARMATURE in collection: "
+ f"{asset_group.name}"
+ )
+ elif len(armatures) > 1:
+ self.log.warning(
+ "Found more than one ARMATURE, using "
+ f"only first of: {armatures}"
+ )
+ armature = armatures[0]
object_action_pairs = []
original_actions = []
@@ -44,9 +98,6 @@ class ExtractAnimationFBX(publish.Extractor):
ending_frames = []
# For each armature, we make a copy of the current action
- curr_action = None
- copy_action = None
-
if armature.animation_data and armature.animation_data.action:
curr_action = armature.animation_data.action
copy_action = curr_action.copy()
@@ -56,12 +107,20 @@ class ExtractAnimationFBX(publish.Extractor):
starting_frames.append(curr_frame_range[0])
ending_frames.append(curr_frame_range[1])
else:
- self.log.info("Object have no animation.")
+ self.log.info(
+ f"Armature '{armature.name}' has no animation, "
+ f"skipping FBX animation extraction for {instance}."
+ )
return
asset_group_name = asset_group.name
- asset_group.name = asset_group.get(AVALON_PROPERTY).get("asset_name")
+ asset_name = asset_group.get(AVALON_PROPERTY).get("asset_name")
+ if asset_name:
+ # Rename for the export; this data is only present when loaded
+ # from a JSON Layout (layout family)
+ asset_group.name = asset_name
+ # Remove : from the armature name for the export
armature_name = armature.name
original_name = armature_name.split(':')[1]
armature.name = original_name
@@ -84,13 +143,16 @@ class ExtractAnimationFBX(publish.Extractor):
for obj in bpy.data.objects:
obj.select_set(False)
- asset_group.select_set(True)
+ root.select_set(True)
armature.select_set(True)
- fbx_filename = f"{instance.name}_{armature.name}.fbx"
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ fbx_filename = f"{instance_name}_{armature.name}.fbx"
filepath = os.path.join(stagingdir, fbx_filename)
override = plugin.create_blender_context(
- active=asset_group, selected=[asset_group, armature])
+ active=root, selected=[root, armature])
bpy.ops.export_scene.fbx(
override,
filepath=filepath,
@@ -104,7 +166,7 @@ class ExtractAnimationFBX(publish.Extractor):
)
armature.name = armature_name
asset_group.name = asset_group_name
- asset_group.select_set(False)
+ root.select_set(True)
armature.select_set(False)
# We delete the baked action and set the original one back
@@ -119,7 +181,7 @@ class ExtractAnimationFBX(publish.Extractor):
pair[1].user_clear()
bpy.data.actions.remove(pair[1])
- json_filename = f"{instance.name}.json"
+ json_filename = f"{instance_name}.json"
json_path = os.path.join(stagingdir, json_filename)
json_dict = {
@@ -158,5 +220,5 @@ class ExtractAnimationFBX(publish.Extractor):
instance.data["representations"].append(fbx_representation)
instance.data["representations"].append(json_representation)
- self.log.info("Extracted instance '{}' to: {}".format(
- instance.name, fbx_representation))
+ self.log.debug("Extracted instance '{}' to: {}".format(
+ instance.name, fbx_representation))
diff --git a/openpype/hosts/blender/plugins/publish/extract_layout.py b/openpype/hosts/blender/plugins/publish/extract_layout.py
index 05f86b8370..41c6b0912c 100644
--- a/openpype/hosts/blender/plugins/publish/extract_layout.py
+++ b/openpype/hosts/blender/plugins/publish/extract_layout.py
@@ -11,7 +11,7 @@ from openpype.hosts.blender.api import plugin
from openpype.hosts.blender.api.pipeline import AVALON_PROPERTY
-class ExtractLayout(publish.Extractor):
+class ExtractLayout(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""Extract a layout."""
label = "Extract Layout"
@@ -45,7 +45,7 @@ class ExtractLayout(publish.Extractor):
starting_frames.append(curr_frame_range[0])
ending_frames.append(curr_frame_range[1])
else:
- self.log.info("Object have no animation.")
+ self.log.info("Object has no animation.")
continue
asset_group_name = asset.name
@@ -113,6 +113,9 @@ class ExtractLayout(publish.Extractor):
return None, n
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
# Define extract output file path
stagingdir = self.staging_dir(instance)
@@ -125,13 +128,22 @@ class ExtractLayout(publish.Extractor):
json_data = []
fbx_files = []
- asset_group = bpy.data.objects[str(instance)]
+ asset_group = instance.data["transientData"]["instance_node"]
fbx_count = 0
project_name = instance.context.data["projectEntity"]["name"]
for asset in asset_group.children:
metadata = asset.get(AVALON_PROPERTY)
+ if not metadata:
+ # Avoid raising error directly if there's just invalid data
+ # inside the instance; better to log it to the artist
+ # TODO: This should actually be validated in a validator
+ self.log.warning(
+ f"Found content in layout that is not a loaded "
+ f"asset, skipping: {asset.name_full}"
+ )
+ continue
version_id = metadata["parent"]
family = metadata["family"]
@@ -212,7 +224,11 @@ class ExtractLayout(publish.Extractor):
json_data.append(json_element)
- json_filename = "{}.json".format(instance.name)
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ instance_name = f"{asset_name}_{subset}"
+ json_filename = f"{instance_name}.json"
+
json_path = os.path.join(stagingdir, json_filename)
with open(json_path, "w+") as file:
@@ -245,5 +261,5 @@ class ExtractLayout(publish.Extractor):
}
instance.data["representations"].append(fbx_representation)
- self.log.info("Extracted instance '%s' to: %s",
- instance.name, json_representation)
+ self.log.debug("Extracted instance '%s' to: %s",
+ instance.name, json_representation)
diff --git a/openpype/hosts/blender/plugins/publish/extract_playblast.py b/openpype/hosts/blender/plugins/publish/extract_playblast.py
index b0099cce85..a78aa14138 100644
--- a/openpype/hosts/blender/plugins/publish/extract_playblast.py
+++ b/openpype/hosts/blender/plugins/publish/extract_playblast.py
@@ -9,7 +9,7 @@ from openpype.hosts.blender.api import capture
from openpype.hosts.blender.api.lib import maintained_time
-class ExtractPlayblast(publish.Extractor):
+class ExtractPlayblast(publish.Extractor, publish.OptionalPyblishPluginMixin):
"""
Extract viewport playblast.
@@ -24,7 +24,8 @@ class ExtractPlayblast(publish.Extractor):
order = pyblish.api.ExtractorOrder + 0.01
def process(self, instance):
- self.log.debug("Extracting capture..")
+ if not self.is_active(instance.data):
+ return
# get scene fps
fps = instance.data.get("fps")
@@ -50,7 +51,10 @@ class ExtractPlayblast(publish.Extractor):
# get output path
stagingdir = self.staging_dir(instance)
- filename = instance.name
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ filename = f"{asset_name}_{subset}"
+
path = os.path.join(stagingdir, filename)
self.log.debug(f"Outputting images to {path}")
diff --git a/openpype/hosts/blender/plugins/publish/extract_thumbnail.py b/openpype/hosts/blender/plugins/publish/extract_thumbnail.py
index 52e5d98fc4..e8a9c68dd1 100644
--- a/openpype/hosts/blender/plugins/publish/extract_thumbnail.py
+++ b/openpype/hosts/blender/plugins/publish/extract_thumbnail.py
@@ -27,7 +27,10 @@ class ExtractThumbnail(publish.Extractor):
self.log.debug("Extracting capture..")
stagingdir = self.staging_dir(instance)
- filename = instance.name
+ asset_name = instance.data["assetEntity"]["name"]
+ subset = instance.data["subset"]
+ filename = f"{asset_name}_{subset}"
+
path = os.path.join(stagingdir, filename)
self.log.debug(f"Outputting images to {path}")
diff --git a/openpype/hosts/blender/plugins/publish/increment_workfile_version.py b/openpype/hosts/blender/plugins/publish/increment_workfile_version.py
index 6ace14d77c..7e33fd53fa 100644
--- a/openpype/hosts/blender/plugins/publish/increment_workfile_version.py
+++ b/openpype/hosts/blender/plugins/publish/increment_workfile_version.py
@@ -1,8 +1,12 @@
import pyblish.api
+from openpype.pipeline.publish import OptionalPyblishPluginMixin
from openpype.hosts.blender.api.workio import save_file
-class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
+class IncrementWorkfileVersion(
+ pyblish.api.ContextPlugin,
+ OptionalPyblishPluginMixin
+):
"""Increment current workfile version."""
order = pyblish.api.IntegratorOrder + 0.9
@@ -13,6 +17,8 @@ class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
"pointcache", "render"]
def process(self, context):
+ if not self.is_active(context.data):
+ return
assert all(result["success"] for result in context.data["results"]), (
"Publishing not successful so version is not increased.")
@@ -23,4 +29,4 @@ class IncrementWorkfileVersion(pyblish.api.ContextPlugin):
save_file(filepath, copy=False)
- self.log.info('Incrementing script version')
+ self.log.debug('Incrementing blender workfile version')
diff --git a/openpype/hosts/blender/plugins/publish/integrate_animation.py b/openpype/hosts/blender/plugins/publish/integrate_animation.py
index d9a85bc79b..623da9c585 100644
--- a/openpype/hosts/blender/plugins/publish/integrate_animation.py
+++ b/openpype/hosts/blender/plugins/publish/integrate_animation.py
@@ -1,9 +1,13 @@
import json
import pyblish.api
+from openpype.pipeline.publish import OptionalPyblishPluginMixin
-class IntegrateAnimation(pyblish.api.InstancePlugin):
+class IntegrateAnimation(
+ pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin,
+):
"""Generate a JSON file for animation."""
label = "Integrate Animation"
@@ -13,7 +17,7 @@ class IntegrateAnimation(pyblish.api.InstancePlugin):
families = ["setdress"]
def process(self, instance):
- self.log.info("Integrate Animation")
+ self.log.debug("Integrate Animation")
representation = instance.data.get('representations')[0]
json_path = representation.get('publishedFiles')[0]
diff --git a/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py b/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py
index 48c267fd18..9b6e513897 100644
--- a/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py
+++ b/openpype/hosts/blender/plugins/publish/validate_camera_zero_keyframe.py
@@ -5,10 +5,15 @@ import bpy
import pyblish.api
import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+ ValidateContentsOrder,
+ PublishValidationError,
+ OptionalPyblishPluginMixin
+)
-class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin):
+class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin):
"""Camera must have a keyframe at frame 0.
Unreal shifts the first keyframe to frame 0. Forcing the camera to have
@@ -40,8 +45,12 @@ class ValidateCameraZeroKeyframe(pyblish.api.InstancePlugin):
return invalid
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
invalid = self.get_invalid(instance)
if invalid:
- raise RuntimeError(
- f"Camera must have a keyframe at frame 0: {invalid}"
+ names = ", ".join(obj.name for obj in invalid)
+ raise PublishValidationError(
+ f"Camera must have a keyframe at frame 0: {names}"
)
diff --git a/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py b/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py
index 14220b5c9c..d8826adc9c 100644
--- a/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py
+++ b/openpype/hosts/blender/plugins/publish/validate_deadline_publish.py
@@ -36,12 +36,12 @@ class ValidateDeadlinePublish(pyblish.api.InstancePlugin,
"Render output folder "
"doesn't match the blender scene name! "
"Use Repair action to "
- "fix the folder file path.."
+ "fix the folder file path."
)
@classmethod
def repair(cls, instance):
- container = bpy.data.collections[str(instance)]
+ container = instance.data["transientData"]["instance_node"]
prepare_rendering(container)
bpy.ops.wm.save_as_mainfile(filepath=bpy.data.filepath)
cls.log.debug("Reset the render output folder...")
diff --git a/openpype/hosts/blender/plugins/publish/validate_file_saved.py b/openpype/hosts/blender/plugins/publish/validate_file_saved.py
index e191585c55..442f856e05 100644
--- a/openpype/hosts/blender/plugins/publish/validate_file_saved.py
+++ b/openpype/hosts/blender/plugins/publish/validate_file_saved.py
@@ -2,8 +2,24 @@ import bpy
import pyblish.api
+from openpype.pipeline.publish import (
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
-class ValidateFileSaved(pyblish.api.InstancePlugin):
+
+class SaveWorkfileAction(pyblish.api.Action):
+ """Save Workfile."""
+ label = "Save Workfile"
+ on = "failed"
+ icon = "save"
+
+ def process(self, context, plugin):
+ bpy.ops.wm.avalon_workfiles()
+
+
+class ValidateFileSaved(pyblish.api.ContextPlugin,
+ OptionalPyblishPluginMixin):
"""Validate that the workfile has been saved."""
order = pyblish.api.ValidatorOrder - 0.01
@@ -11,10 +27,35 @@ class ValidateFileSaved(pyblish.api.InstancePlugin):
label = "Validate File Saved"
optional = False
exclude_families = []
+ actions = [SaveWorkfileAction]
- def process(self, instance):
- if [ef for ef in self.exclude_families
- if instance.data["family"] in ef]:
+ def process(self, context):
+ if not self.is_active(context.data):
return
+
+ if not context.data["currentFile"]:
+ # File has not been saved at all and has no filename
+ raise PublishValidationError(
+ "Current file is empty. Save the file before continuing."
+ )
+
+ # Do not validate workfile has unsaved changes if only instances
+ # present of families that should be excluded
+ families = {
+ instance.data["family"] for instance in context
+ # Consider only enabled instances
+ if instance.data.get("publish", True)
+ and instance.data.get("active", True)
+ }
+
+ def is_excluded(family):
+ return any(family in exclude_family
+ for exclude_family in self.exclude_families)
+
+ if all(is_excluded(family) for family in families):
+ self.log.debug("Only excluded families found, skipping workfile "
+ "unsaved changes validation..")
+ return
+
if bpy.data.is_dirty:
- raise RuntimeError("Workfile is not saved.")
+ raise PublishValidationError("Workfile has unsaved changes.")
diff --git a/openpype/hosts/blender/plugins/publish/validate_instance_empty.py b/openpype/hosts/blender/plugins/publish/validate_instance_empty.py
index 3ebc6515d3..51a1dcf6ca 100644
--- a/openpype/hosts/blender/plugins/publish/validate_instance_empty.py
+++ b/openpype/hosts/blender/plugins/publish/validate_instance_empty.py
@@ -1,6 +1,5 @@
-import bpy
-
import pyblish.api
+from openpype.pipeline.publish import PublishValidationError
class ValidateInstanceEmpty(pyblish.api.InstancePlugin):
@@ -13,11 +12,8 @@ class ValidateInstanceEmpty(pyblish.api.InstancePlugin):
optional = False
def process(self, instance):
- asset_group = instance.data["instance_group"]
-
- if isinstance(asset_group, bpy.types.Collection):
- if not (asset_group.objects or asset_group.children):
- raise RuntimeError(f"Instance {instance.name} is empty.")
- elif isinstance(asset_group, bpy.types.Object):
- if not asset_group.children:
- raise RuntimeError(f"Instance {instance.name} is empty.")
+ # Members are collected by `collect_instance` so we only need to check
+ # whether any member is included. The instance node will be included
+ # as a member as well, hence we will check for at least 2 members
+ if len(instance) < 2:
+ raise PublishValidationError(f"Instance {instance.name} is empty.")
diff --git a/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py b/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py
index edf47193be..060bccbd04 100644
--- a/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py
+++ b/openpype/hosts/blender/plugins/publish/validate_mesh_has_uv.py
@@ -4,17 +4,24 @@ import bpy
import pyblish.api
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+ ValidateContentsOrder,
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
import openpype.hosts.blender.api.action
-class ValidateMeshHasUvs(pyblish.api.InstancePlugin):
+class ValidateMeshHasUvs(
+ pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin,
+):
"""Validate that the current mesh has UV's."""
order = ValidateContentsOrder
hosts = ["blender"]
families = ["model"]
- label = "Mesh Has UV's"
+ label = "Mesh Has UVs"
actions = [openpype.hosts.blender.api.action.SelectInvalidAction]
optional = True
@@ -49,8 +56,11 @@ class ValidateMeshHasUvs(pyblish.api.InstancePlugin):
return invalid
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
invalid = self.get_invalid(instance)
if invalid:
- raise RuntimeError(
+ raise PublishValidationError(
f"Meshes found in instance without valid UV's: {invalid}"
)
diff --git a/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py b/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py
index 618feb95c1..7f77bbe38c 100644
--- a/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py
+++ b/openpype/hosts/blender/plugins/publish/validate_mesh_no_negative_scale.py
@@ -4,11 +4,16 @@ import bpy
import pyblish.api
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+ ValidateContentsOrder,
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
import openpype.hosts.blender.api.action
-class ValidateMeshNoNegativeScale(pyblish.api.Validator):
+class ValidateMeshNoNegativeScale(pyblish.api.Validator,
+ OptionalPyblishPluginMixin):
"""Ensure that meshes don't have a negative scale."""
order = ValidateContentsOrder
@@ -27,8 +32,12 @@ class ValidateMeshNoNegativeScale(pyblish.api.Validator):
return invalid
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
invalid = self.get_invalid(instance)
if invalid:
- raise RuntimeError(
- f"Meshes found in instance with negative scale: {invalid}"
+ names = ", ".join(obj.name for obj in invalid)
+ raise PublishValidationError(
+ f"Meshes found in instance with negative scale: {names}"
)
diff --git a/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py b/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py
index 1a98ec4c1d..caf555b535 100644
--- a/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py
+++ b/openpype/hosts/blender/plugins/publish/validate_no_colons_in_name.py
@@ -5,10 +5,15 @@ import bpy
import pyblish.api
import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+ ValidateContentsOrder,
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
-class ValidateNoColonsInName(pyblish.api.InstancePlugin):
+class ValidateNoColonsInName(pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin):
"""There cannot be colons in names
Object or bone names cannot include colons. Other software do not
@@ -36,8 +41,12 @@ class ValidateNoColonsInName(pyblish.api.InstancePlugin):
return invalid
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
invalid = self.get_invalid(instance)
if invalid:
- raise RuntimeError(
- f"Objects found with colon in name: {invalid}"
+ names = ", ".join(obj.name for obj in invalid)
+ raise PublishValidationError(
+ f"Objects found with colon in name: {names}"
)
diff --git a/openpype/hosts/blender/plugins/publish/validate_object_mode.py b/openpype/hosts/blender/plugins/publish/validate_object_mode.py
index ac60e00f89..ab5f4bb467 100644
--- a/openpype/hosts/blender/plugins/publish/validate_object_mode.py
+++ b/openpype/hosts/blender/plugins/publish/validate_object_mode.py
@@ -3,10 +3,17 @@ from typing import List
import bpy
import pyblish.api
+from openpype.pipeline.publish import (
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
import openpype.hosts.blender.api.action
-class ValidateObjectIsInObjectMode(pyblish.api.InstancePlugin):
+class ValidateObjectIsInObjectMode(
+ pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin,
+):
"""Validate that the objects in the instance are in Object Mode."""
order = pyblish.api.ValidatorOrder - 0.01
@@ -25,8 +32,12 @@ class ValidateObjectIsInObjectMode(pyblish.api.InstancePlugin):
return invalid
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
invalid = self.get_invalid(instance)
if invalid:
- raise RuntimeError(
- f"Object found in instance is not in Object Mode: {invalid}"
+ names = ", ".join(obj.name for obj in invalid)
+ raise PublishValidationError(
+ f"Object found in instance is not in Object Mode: {names}"
)
diff --git a/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py b/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py
index ba3a796f35..86d1fcc681 100644
--- a/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py
+++ b/openpype/hosts/blender/plugins/publish/validate_render_camera_is_set.py
@@ -2,8 +2,14 @@ import bpy
import pyblish.api
+from openpype.pipeline.publish import (
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
-class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin):
+
+class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin):
"""Validate that there is a camera set as active for rendering."""
order = pyblish.api.ValidatorOrder
@@ -13,5 +19,8 @@ class ValidateRenderCameraIsSet(pyblish.api.InstancePlugin):
optional = False
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
if not bpy.context.scene.camera:
- raise RuntimeError("No camera is active for rendering.")
+ raise PublishValidationError("No camera is active for rendering.")
diff --git a/openpype/hosts/blender/plugins/publish/validate_transform_zero.py b/openpype/hosts/blender/plugins/publish/validate_transform_zero.py
index 66ef731e6e..1fb9535ee4 100644
--- a/openpype/hosts/blender/plugins/publish/validate_transform_zero.py
+++ b/openpype/hosts/blender/plugins/publish/validate_transform_zero.py
@@ -6,10 +6,15 @@ import bpy
import pyblish.api
import openpype.hosts.blender.api.action
-from openpype.pipeline.publish import ValidateContentsOrder
+from openpype.pipeline.publish import (
+ ValidateContentsOrder,
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
-class ValidateTransformZero(pyblish.api.InstancePlugin):
+class ValidateTransformZero(pyblish.api.InstancePlugin,
+ OptionalPyblishPluginMixin):
"""Transforms can't have any values
To solve this issue, try freezing the transforms. So long
@@ -38,9 +43,13 @@ class ValidateTransformZero(pyblish.api.InstancePlugin):
return invalid
def process(self, instance):
+ if not self.is_active(instance.data):
+ return
+
invalid = self.get_invalid(instance)
if invalid:
- raise RuntimeError(
- "Object found in instance has not"
- f" transform to zero: {invalid}"
+ names = ", ".join(obj.name for obj in invalid)
+ raise PublishValidationError(
+ "Objects found in instance which do not"
+ f" have transform set to zero: {names}"
)
diff --git a/openpype/hosts/celaction/plugins/publish/collect_celaction_instances.py b/openpype/hosts/celaction/plugins/publish/collect_celaction_instances.py
index c815c1edd4..875f15fcc5 100644
--- a/openpype/hosts/celaction/plugins/publish/collect_celaction_instances.py
+++ b/openpype/hosts/celaction/plugins/publish/collect_celaction_instances.py
@@ -1,6 +1,8 @@
import os
import pyblish.api
+from openpype.client import get_asset_name_identifier
+
class CollectCelactionInstances(pyblish.api.ContextPlugin):
""" Adds the celaction render instances """
@@ -17,8 +19,10 @@ class CollectCelactionInstances(pyblish.api.ContextPlugin):
asset_entity = context.data["assetEntity"]
project_entity = context.data["projectEntity"]
+ asset_name = get_asset_name_identifier(asset_entity)
+
shared_instance_data = {
- "asset": asset_entity["name"],
+ "asset": asset_name,
"frameStart": asset_entity["data"]["frameStart"],
"frameEnd": asset_entity["data"]["frameEnd"],
"handleStart": asset_entity["data"]["handleStart"],
diff --git a/openpype/hosts/flame/plugins/publish/collect_timeline_otio.py b/openpype/hosts/flame/plugins/publish/collect_timeline_otio.py
index f8cfa9e963..20ac048986 100644
--- a/openpype/hosts/flame/plugins/publish/collect_timeline_otio.py
+++ b/openpype/hosts/flame/plugins/publish/collect_timeline_otio.py
@@ -1,5 +1,6 @@
import pyblish.api
+from openpype.client import get_asset_name_identifier
import openpype.hosts.flame.api as opfapi
from openpype.hosts.flame.otio import flame_export
from openpype.pipeline.create import get_subset_name
@@ -33,13 +34,15 @@ class CollecTimelineOTIO(pyblish.api.ContextPlugin):
project_settings=context.data["project_settings"]
)
+ asset_name = get_asset_name_identifier(asset_doc)
+
# adding otio timeline to context
with opfapi.maintained_segment_selection(sequence) as selected_seg:
otio_timeline = flame_export.create_otio_timeline(sequence)
instance_data = {
"name": subset_name,
- "asset": asset_doc["name"],
+ "asset": asset_name,
"subset": subset_name,
"family": "workfile",
"families": []
diff --git a/openpype/hosts/fusion/plugins/create/create_saver.py b/openpype/hosts/fusion/plugins/create/create_saver.py
index 2dc48f4b60..ecf36abdd2 100644
--- a/openpype/hosts/fusion/plugins/create/create_saver.py
+++ b/openpype/hosts/fusion/plugins/create/create_saver.py
@@ -149,9 +149,7 @@ class CreateSaver(NewCreator):
# get frame padding from anatomy templates
anatomy = Anatomy()
- frame_padding = int(
- anatomy.templates["render"].get("frame_padding", 4)
- )
+ frame_padding = anatomy.templates["frame_padding"]
# Subset change detected
workdir = os.path.normpath(legacy_io.Session["AVALON_WORKDIR"])
diff --git a/openpype/hosts/fusion/plugins/create/create_workfile.py b/openpype/hosts/fusion/plugins/create/create_workfile.py
index 8acaaa172f..4092086ea4 100644
--- a/openpype/hosts/fusion/plugins/create/create_workfile.py
+++ b/openpype/hosts/fusion/plugins/create/create_workfile.py
@@ -1,6 +1,7 @@
from openpype.hosts.fusion.api import (
get_current_comp
)
+from openpype import AYON_SERVER_ENABLED
from openpype.client import get_asset_by_name
from openpype.pipeline import (
AutoCreator,
@@ -68,6 +69,13 @@ class FusionWorkfileCreator(AutoCreator):
task_name = self.create_context.get_current_task_name()
host_name = self.create_context.host_name
+ if existing_instance is None:
+ existing_instance_asset = None
+ elif AYON_SERVER_ENABLED:
+ existing_instance_asset = existing_instance["folderPath"]
+ else:
+ existing_instance_asset = existing_instance["asset"]
+
if existing_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
@@ -75,10 +83,13 @@ class FusionWorkfileCreator(AutoCreator):
project_name, host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": self.default_variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
data.update(self.get_dynamic_data(
self.default_variant, task_name, asset_doc,
project_name, host_name, None
@@ -91,7 +102,7 @@ class FusionWorkfileCreator(AutoCreator):
self._add_instance_to_context(new_instance)
elif (
- existing_instance["asset"] != asset_name
+ existing_instance_asset != asset_name
or existing_instance["task"] != task_name
):
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -99,6 +110,9 @@ class FusionWorkfileCreator(AutoCreator):
self.default_variant, task_name, asset_doc,
project_name, host_name
)
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/hiero/api/plugin.py b/openpype/hosts/hiero/api/plugin.py
index 52f96261b2..b0c73e41fb 100644
--- a/openpype/hosts/hiero/api/plugin.py
+++ b/openpype/hosts/hiero/api/plugin.py
@@ -11,7 +11,6 @@ import qargparse
from openpype.settings import get_current_project_settings
from openpype.lib import Logger
from openpype.pipeline import LoaderPlugin, LegacyCreator
-from openpype.pipeline.context_tools import get_current_project_asset
from openpype.pipeline.load import get_representation_path_from_context
from . import lib
@@ -32,7 +31,7 @@ def load_stylesheet():
class CreatorWidget(QtWidgets.QDialog):
# output items
- items = dict()
+ items = {}
def __init__(self, name, info, ui_inputs, parent=None):
super(CreatorWidget, self).__init__(parent)
@@ -494,9 +493,8 @@ class ClipLoader:
joint `data` key with asset.data dict into the representation
"""
- asset_name = self.context["representation"]["context"]["asset"]
- asset_doc = get_current_project_asset(asset_name)
- log.debug("__ asset_doc: {}".format(pformat(asset_doc)))
+
+ asset_doc = self.context["asset"]
self.data["assetData"] = asset_doc["data"]
def _make_track_item(self, source_bin_item, audio=False):
@@ -644,8 +642,8 @@ class PublishClip:
Returns:
hiero.core.TrackItem: hiero track item object with pype tag
"""
- vertical_clip_match = dict()
- tag_data = dict()
+ vertical_clip_match = {}
+ tag_data = {}
types = {
"shot": "shot",
"folder": "folder",
@@ -707,9 +705,10 @@ class PublishClip:
self._create_parents()
def convert(self):
-
# solve track item data and add them to tag data
- self._convert_to_tag_data()
+ tag_hierarchy_data = self._convert_to_tag_data()
+
+ self.tag_data.update(tag_hierarchy_data)
# if track name is in review track name and also if driving track name
# is not in review track name: skip tag creation
@@ -723,16 +722,23 @@ class PublishClip:
if self.rename:
# rename track item
self.track_item.setName(new_name)
- self.tag_data["asset"] = new_name
+ self.tag_data["asset_name"] = new_name
else:
- self.tag_data["asset"] = self.ti_name
+ self.tag_data["asset_name"] = self.ti_name
self.tag_data["hierarchyData"]["shot"] = self.ti_name
+ # AYON unique identifier
+ folder_path = "/{}/{}".format(
+ tag_hierarchy_data["hierarchy"],
+ self.tag_data["asset_name"]
+ )
+ self.tag_data["folderPath"] = folder_path
if self.tag_data["heroTrack"] and self.review_layer:
self.tag_data.update({"reviewTrack": self.review_layer})
else:
self.tag_data.update({"reviewTrack": None})
+ # TODO: remove debug print
log.debug("___ self.tag_data: {}".format(
pformat(self.tag_data)
))
@@ -891,7 +897,7 @@ class PublishClip:
tag_hierarchy_data = hero_data
# add data to return data dict
- self.tag_data.update(tag_hierarchy_data)
+ return tag_hierarchy_data
def _solve_tag_hierarchy_data(self, hierarchy_formatting_data):
""" Solve tag data from hierarchy data and templates. """
diff --git a/openpype/hosts/hiero/plugins/publish/collect_frame_tag_instances.py b/openpype/hosts/hiero/plugins/publish/collect_frame_tag_instances.py
index 982a34efd6..79bf67b336 100644
--- a/openpype/hosts/hiero/plugins/publish/collect_frame_tag_instances.py
+++ b/openpype/hosts/hiero/plugins/publish/collect_frame_tag_instances.py
@@ -5,6 +5,8 @@ import json
import pyblish.api
+from openpype.client import get_asset_name_identifier
+
class CollectFrameTagInstances(pyblish.api.ContextPlugin):
"""Collect frames from tags.
@@ -99,6 +101,9 @@ class CollectFrameTagInstances(pyblish.api.ContextPlugin):
# first collect all available subset tag frames
subset_data = {}
+ context_asset_doc = context.data["assetEntity"]
+ context_asset_name = get_asset_name_identifier(context_asset_doc)
+
for tag_data in sequence_tags:
frame = int(tag_data["start"])
@@ -115,7 +120,7 @@ class CollectFrameTagInstances(pyblish.api.ContextPlugin):
subset_data[subset] = {
"frames": [frame],
"format": tag_data["format"],
- "asset": context.data["assetEntity"]["name"]
+ "asset": context_asset_name
}
return subset_data
diff --git a/openpype/hosts/hiero/plugins/publish/precollect_instances.py b/openpype/hosts/hiero/plugins/publish/precollect_instances.py
index 3f9da2cf60..590d7b7050 100644
--- a/openpype/hosts/hiero/plugins/publish/precollect_instances.py
+++ b/openpype/hosts/hiero/plugins/publish/precollect_instances.py
@@ -1,9 +1,12 @@
import pyblish
+
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline.editorial import is_overlapping_otio_ranges
+
from openpype.hosts.hiero import api as phiero
from openpype.hosts.hiero.api.otio import hiero_export
-import hiero
+import hiero
# # developer reload modules
from pprint import pformat
@@ -80,25 +83,24 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
if k not in ("id", "applieswhole", "label")
})
- asset = tag_data["asset"]
+ asset, asset_name = self._get_asset_data(tag_data)
+
subset = tag_data["subset"]
# insert family into families
- family = tag_data["family"]
families = [str(f) for f in tag_data["families"]]
- families.insert(0, str(family))
# form label
- label = asset
- if asset != clip_name:
+ label = "{} -".format(asset)
+ if asset_name != clip_name:
label += " ({})".format(clip_name)
label += " {}".format(subset)
- label += " {}".format("[" + ", ".join(families) + "]")
data.update({
"name": "{}_{}".format(asset, subset),
"label": label,
"asset": asset,
+ "asset_name": asset_name,
"item": track_item,
"families": families,
"publish": tag_data["publish"],
@@ -176,9 +178,9 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
})
def create_shot_instance(self, context, **data):
+ subset = "shotMain"
master_layer = data.get("heroTrack")
hierarchy_data = data.get("hierarchyData")
- asset = data.get("asset")
item = data.get("item")
clip_name = item.name()
@@ -189,23 +191,21 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
return
asset = data["asset"]
- subset = "shotMain"
+ asset_name = data["asset_name"]
# insert family into families
family = "shot"
# form label
- label = asset
- if asset != clip_name:
+ label = "{} -".format(asset)
+ if asset_name != clip_name:
label += " ({}) ".format(clip_name)
label += " {}".format(subset)
- label += " [{}]".format(family)
data.update({
"name": "{}_{}".format(asset, subset),
"label": label,
"subset": subset,
- "asset": asset,
"family": family,
"families": []
})
@@ -215,7 +215,33 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
self.log.debug(
"_ instance.data: {}".format(pformat(instance.data)))
+ def _get_asset_data(self, data):
+ folder_path = data.pop("folderPath", None)
+
+ if data.get("asset_name"):
+ asset_name = data["asset_name"]
+ else:
+ asset_name = data["asset"]
+
+ # backward compatibility for clip tags
+ # which are missing folderPath key
+ # TODO remove this in future versions
+ if not folder_path:
+ hierarchy_path = data["hierarchy"]
+ folder_path = "/{}/{}".format(
+ hierarchy_path,
+ asset_name
+ )
+
+ if AYON_SERVER_ENABLED:
+ asset = folder_path
+ else:
+ asset = asset_name
+
+ return asset, asset_name
+
def create_audio_instance(self, context, **data):
+ subset = "audioMain"
master_layer = data.get("heroTrack")
if not master_layer:
@@ -230,23 +256,21 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
return
asset = data["asset"]
- subset = "audioMain"
+ asset_name = data["asset_name"]
# insert family into families
family = "audio"
# form label
- label = asset
- if asset != clip_name:
+ label = "{} -".format(asset)
+ if asset_name != clip_name:
label += " ({}) ".format(clip_name)
label += " {}".format(subset)
- label += " [{}]".format(family)
data.update({
"name": "{}_{}".format(asset, subset),
"label": label,
"subset": subset,
- "asset": asset,
"family": family,
"families": ["clip"]
})
diff --git a/openpype/hosts/hiero/plugins/publish/precollect_workfile.py b/openpype/hosts/hiero/plugins/publish/precollect_workfile.py
index 5a66581531..8abb0885c6 100644
--- a/openpype/hosts/hiero/plugins/publish/precollect_workfile.py
+++ b/openpype/hosts/hiero/plugins/publish/precollect_workfile.py
@@ -7,6 +7,7 @@ from qtpy.QtGui import QPixmap
import hiero.ui
+from openpype import AYON_SERVER_ENABLED
from openpype.hosts.hiero.api.otio import hiero_export
@@ -17,9 +18,11 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
order = pyblish.api.CollectorOrder - 0.491
def process(self, context):
-
asset = context.data["asset"]
- subset = "workfile"
+ asset_name = asset
+ if AYON_SERVER_ENABLED:
+ asset_name = asset_name.split("/")[-1]
+
active_timeline = hiero.ui.activeSequence()
project = active_timeline.project()
fps = active_timeline.framerate().toFloat()
@@ -27,7 +30,7 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
# adding otio timeline to context
otio_timeline = hiero_export.create_otio_timeline()
- # get workfile thumnail paths
+ # get workfile thumbnail paths
tmp_staging = tempfile.mkdtemp(prefix="pyblish_tmp_")
thumbnail_name = "workfile_thumbnail.png"
thumbnail_path = os.path.join(tmp_staging, thumbnail_name)
@@ -49,8 +52,8 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
}
# get workfile paths
- curent_file = project.path()
- staging_dir, base_name = os.path.split(curent_file)
+ current_file = project.path()
+ staging_dir, base_name = os.path.split(current_file)
# creating workfile representation
workfile_representation = {
@@ -59,13 +62,16 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
'files': base_name,
"stagingDir": staging_dir,
}
-
+ family = "workfile"
instance_data = {
- "name": "{}_{}".format(asset, subset),
- "asset": asset,
- "subset": "{}{}".format(asset, subset.capitalize()),
+ "label": "{} - {}Main".format(
+ asset, family),
+ "name": "{}_{}".format(asset_name, family),
+ "asset": context.data["asset"],
+ # TODO use 'get_subset_name'
+ "subset": "{}{}Main".format(asset_name, family.capitalize()),
"item": project,
- "family": "workfile",
+ "family": family,
"families": [],
"representations": [workfile_representation, thumb_representation]
}
@@ -78,7 +84,7 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
"activeProject": project,
"activeTimeline": active_timeline,
"otioTimeline": otio_timeline,
- "currentFile": curent_file,
+ "currentFile": current_file,
"colorspace": self.get_colorspace(project),
"fps": fps
}
diff --git a/openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py b/openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py
index 767f7c30f7..37370497a5 100644
--- a/openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py
+++ b/openpype/hosts/hiero/plugins/publish_old_workflow/collect_assetbuilds.py
@@ -1,5 +1,6 @@
from pyblish import api
-from openpype.client import get_assets
+
+from openpype.client import get_assets, get_asset_name_identifier
class CollectAssetBuilds(api.ContextPlugin):
@@ -19,10 +20,13 @@ class CollectAssetBuilds(api.ContextPlugin):
def process(self, context):
project_name = context.data["projectName"]
asset_builds = {}
- for asset in get_assets(project_name):
- if asset["data"]["entityType"] == "AssetBuild":
- self.log.debug("Found \"{}\" in database.".format(asset))
- asset_builds[asset["name"]] = asset
+ for asset_doc in get_assets(project_name):
+ if asset_doc["data"].get("entityType") != "AssetBuild":
+ continue
+
+ asset_name = get_asset_name_identifier(asset_doc)
+ self.log.debug("Found \"{}\" in database.".format(asset_doc))
+ asset_builds[asset_name] = asset_doc
for instance in context:
if instance.data["family"] != "clip":
@@ -50,9 +54,7 @@ class CollectAssetBuilds(api.ContextPlugin):
# Collect asset builds.
data = {"assetbuilds": []}
for name in asset_names:
- data["assetbuilds"].append(
- asset_builds[name]
- )
+ data["assetbuilds"].append(asset_builds[name])
self.log.debug(
"Found asset builds: {}".format(data["assetbuilds"])
)
diff --git a/openpype/hosts/houdini/api/plugin.py b/openpype/hosts/houdini/api/plugin.py
index 72565f7211..e162d0e461 100644
--- a/openpype/hosts/houdini/api/plugin.py
+++ b/openpype/hosts/houdini/api/plugin.py
@@ -6,6 +6,8 @@ from abc import (
)
import six
import hou
+
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline import (
CreatorError,
LegacyCreator,
@@ -142,12 +144,13 @@ class HoudiniCreatorBase(object):
@staticmethod
def create_instance_node(
- node_name, parent,
- node_type="geometry"):
+ asset_name, node_name, parent, node_type="geometry"
+ ):
# type: (str, str, str) -> hou.Node
"""Create node representing instance.
Arguments:
+ asset_name (str): Asset name.
node_name (str): Name of the new node.
parent (str): Name of the parent node.
node_type (str, optional): Type of the node.
@@ -182,8 +185,13 @@ class HoudiniCreator(NewCreator, HoudiniCreatorBase):
if node_type is None:
node_type = "geometry"
+ if AYON_SERVER_ENABLED:
+ asset_name = instance_data["folderPath"]
+ else:
+ asset_name = instance_data["asset"]
+
instance_node = self.create_instance_node(
- subset_name, "/out", node_type)
+ asset_name, subset_name, "/out", node_type)
self.customize_node_look(instance_node)
diff --git a/openpype/hosts/houdini/plugins/create/create_hda.py b/openpype/hosts/houdini/plugins/create/create_hda.py
index ac075d2072..f670b55eb6 100644
--- a/openpype/hosts/houdini/plugins/create/create_hda.py
+++ b/openpype/hosts/houdini/plugins/create/create_hda.py
@@ -17,13 +17,13 @@ class CreateHDA(plugin.HoudiniCreator):
icon = "gears"
maintain_selection = False
- def _check_existing(self, subset_name):
+ def _check_existing(self, asset_name, subset_name):
# type: (str) -> bool
"""Check if existing subset name versions already exists."""
# Get all subsets of the current asset
project_name = self.project_name
asset_doc = get_asset_by_name(
- project_name, self.data["asset"], fields=["_id"]
+ project_name, asset_name, fields=["_id"]
)
subset_docs = get_subsets(
project_name, asset_ids=[asset_doc["_id"]], fields=["name"]
@@ -35,7 +35,8 @@ class CreateHDA(plugin.HoudiniCreator):
return subset_name.lower() in existing_subset_names_low
def create_instance_node(
- self, node_name, parent, node_type="geometry"):
+ self, asset_name, node_name, parent, node_type="geometry"
+ ):
parent_node = hou.node("/obj")
if self.selected_nodes:
@@ -61,7 +62,7 @@ class CreateHDA(plugin.HoudiniCreator):
hda_file_name="$HIP/{}.hda".format(node_name)
)
hda_node.layoutChildren()
- elif self._check_existing(node_name):
+ elif self._check_existing(asset_name, node_name):
raise plugin.OpenPypeCreatorError(
("subset {} is already published with different HDA"
"definition.").format(node_name))
diff --git a/openpype/hosts/houdini/plugins/create/create_workfile.py b/openpype/hosts/houdini/plugins/create/create_workfile.py
index cc45a6c2a8..850f5c994e 100644
--- a/openpype/hosts/houdini/plugins/create/create_workfile.py
+++ b/openpype/hosts/houdini/plugins/create/create_workfile.py
@@ -1,5 +1,6 @@
# -*- coding: utf-8 -*-
"""Creator plugin for creating workfiles."""
+from openpype import AYON_SERVER_ENABLED
from openpype.hosts.houdini.api import plugin
from openpype.hosts.houdini.api.lib import read, imprint
from openpype.hosts.houdini.api.pipeline import CONTEXT_CONTAINER
@@ -30,16 +31,27 @@ class CreateWorkfile(plugin.HoudiniCreatorBase, AutoCreator):
task_name = self.create_context.get_current_task_name()
host_name = self.host_name
+ if current_instance is None:
+ current_instance_asset = None
+ elif AYON_SERVER_ENABLED:
+ current_instance_asset = current_instance["folderPath"]
+ else:
+ current_instance_asset = current_instance["asset"]
+
if current_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
variant, task_name, asset_doc, project_name, host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
+
data.update(
self.get_dynamic_data(
variant, task_name, asset_doc,
@@ -51,15 +63,18 @@ class CreateWorkfile(plugin.HoudiniCreatorBase, AutoCreator):
)
self._add_instance_to_context(current_instance)
elif (
- current_instance["asset"] != asset_name
- or current_instance["task"] != task_name
+ current_instance_asset != asset_name
+ or current_instance["task"] != task_name
):
# Update instance context if is not the same
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
variant, task_name, asset_doc, project_name, host_name
)
- current_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ current_instance["folderPath"] = asset_name
+ else:
+ current_instance["asset"] = asset_name
current_instance["task"] = task_name
current_instance["subset"] = subset_name
diff --git a/openpype/hosts/houdini/plugins/publish/collect_usd_bootstrap.py b/openpype/hosts/houdini/plugins/publish/collect_usd_bootstrap.py
index 14a8e3c056..462cf99b9c 100644
--- a/openpype/hosts/houdini/plugins/publish/collect_usd_bootstrap.py
+++ b/openpype/hosts/houdini/plugins/publish/collect_usd_bootstrap.py
@@ -1,6 +1,10 @@
import pyblish.api
-from openpype.client import get_subset_by_name, get_asset_by_name
+from openpype.client import (
+ get_subset_by_name,
+ get_asset_by_name,
+ get_asset_name_identifier,
+)
import openpype.lib.usdlib as usdlib
@@ -51,8 +55,9 @@ class CollectUsdBootstrap(pyblish.api.InstancePlugin):
self.log.debug("Add bootstrap for: %s" % bootstrap)
project_name = instance.context.data["projectName"]
- asset = get_asset_by_name(project_name, instance.data["asset"])
- assert asset, "Asset must exist: %s" % asset
+ asset_name = instance.data["asset"]
+ asset_doc = get_asset_by_name(project_name, asset_name)
+ assert asset_doc, "Asset must exist: %s" % asset_name
# Check which are not about to be created and don't exist yet
required = {"shot": ["usdShot"], "asset": ["usdAsset"]}.get(bootstrap)
@@ -67,19 +72,21 @@ class CollectUsdBootstrap(pyblish.api.InstancePlugin):
required += list(layers)
self.log.debug("Checking required bootstrap: %s" % required)
- for subset in required:
- if self._subset_exists(project_name, instance, subset, asset):
+ for subset_name in required:
+ if self._subset_exists(
+ project_name, instance, subset_name, asset_doc
+ ):
continue
self.log.debug(
"Creating {0} USD bootstrap: {1} {2}".format(
- bootstrap, asset["name"], subset
+ bootstrap, asset_name, subset_name
)
)
- new = instance.context.create_instance(subset)
- new.data["subset"] = subset
- new.data["label"] = "{0} ({1})".format(subset, asset["name"])
+ new = instance.context.create_instance(subset_name)
+ new.data["subset"] = subset_name
+ new.data["label"] = "{0} ({1})".format(subset_name, asset_name)
new.data["family"] = "usd.bootstrap"
new.data["comment"] = "Automated bootstrap USD file."
new.data["publishFamilies"] = ["usd"]
@@ -91,21 +98,23 @@ class CollectUsdBootstrap(pyblish.api.InstancePlugin):
for key in ["asset"]:
new.data[key] = instance.data[key]
- def _subset_exists(self, project_name, instance, subset, asset):
+ def _subset_exists(self, project_name, instance, subset_name, asset_doc):
"""Return whether subset exists in current context or in database."""
# Allow it to be created during this publish session
context = instance.context
+
+ asset_doc_name = get_asset_name_identifier(asset_doc)
for inst in context:
if (
- inst.data["subset"] == subset
- and inst.data["asset"] == asset["name"]
+ inst.data["subset"] == subset_name
+ and inst.data["asset"] == asset_doc_name
):
return True
# Or, if they already exist in the database we can
# skip them too.
if get_subset_by_name(
- project_name, subset, asset["_id"], fields=["_id"]
+ project_name, subset_name, asset_doc["_id"], fields=["_id"]
):
return True
return False
diff --git a/openpype/hosts/houdini/plugins/publish/validate_subset_name.py b/openpype/hosts/houdini/plugins/publish/validate_subset_name.py
index bb3648f361..7bed74ebb1 100644
--- a/openpype/hosts/houdini/plugins/publish/validate_subset_name.py
+++ b/openpype/hosts/houdini/plugins/publish/validate_subset_name.py
@@ -54,12 +54,13 @@ class ValidateSubsetName(pyblish.api.InstancePlugin,
rop_node = hou.node(instance.data["instance_node"])
# Check subset name
+ asset_doc = instance.data["assetEntity"]
subset_name = get_subset_name(
family=instance.data["family"],
variant=instance.data["variant"],
task_name=instance.data["task"],
- asset_doc=instance.data["assetEntity"],
- dynamic_data={"asset": instance.data["asset"]}
+ asset_doc=asset_doc,
+ dynamic_data={"asset": asset_doc["name"]}
)
if instance.data.get("subset") != subset_name:
@@ -76,12 +77,13 @@ class ValidateSubsetName(pyblish.api.InstancePlugin,
rop_node = hou.node(instance.data["instance_node"])
# Check subset name
+ asset_doc = instance.data["assetEntity"]
subset_name = get_subset_name(
family=instance.data["family"],
variant=instance.data["variant"],
task_name=instance.data["task"],
- asset_doc=instance.data["assetEntity"],
- dynamic_data={"asset": instance.data["asset"]}
+ asset_doc=asset_doc,
+ dynamic_data={"asset": asset_doc["name"]}
)
instance.data["subset"] = subset_name
diff --git a/openpype/hosts/max/api/lib.py b/openpype/hosts/max/api/lib.py
index cbaf8a0c33..298084a4e8 100644
--- a/openpype/hosts/max/api/lib.py
+++ b/openpype/hosts/max/api/lib.py
@@ -359,8 +359,6 @@ def reset_colorspace():
colorspace_mgr.Mode = rt.Name("OCIO_Custom")
colorspace_mgr.OCIOConfigPath = ocio_config_path
- colorspace_mgr.OCIOConfigPath = ocio_config_path
-
def check_colorspace():
parent = get_main_window()
diff --git a/openpype/hosts/max/api/plugin.py b/openpype/hosts/max/api/plugin.py
index fa6db073db..2cf0d69146 100644
--- a/openpype/hosts/max/api/plugin.py
+++ b/openpype/hosts/max/api/plugin.py
@@ -204,6 +204,8 @@ class MaxCreator(Creator, MaxCreatorBase):
def create(self, subset_name, instance_data, pre_create_data):
if pre_create_data.get("use_selection"):
self.selected_nodes = rt.GetCurrentSelection()
+ if rt.getNodeByName(subset_name):
+ raise CreatorError(f"'{subset_name}' is already created..")
instance_node = self.create_instance_node(subset_name)
instance_data["instance_node"] = instance_node.name
@@ -246,14 +248,25 @@ class MaxCreator(Creator, MaxCreatorBase):
def update_instances(self, update_list):
for created_inst, changes in update_list:
instance_node = created_inst.get("instance_node")
-
new_values = {
key: changes[key].new_value
for key in changes.changed_keys
}
+ subset = new_values.get("subset", "")
+ if subset and instance_node != subset:
+ node = rt.getNodeByName(instance_node)
+ new_subset_name = new_values["subset"]
+ if rt.getNodeByName(new_subset_name):
+ raise CreatorError(
+ "The subset '{}' already exists.".format(
+ new_subset_name))
+ instance_node = new_subset_name
+ created_inst["instance_node"] = instance_node
+ node.name = instance_node
+
imprint(
instance_node,
- new_values,
+ created_inst.data_to_store(),
)
def remove_instances(self, instances):
diff --git a/openpype/hosts/max/plugins/publish/validate_loaded_plugin.py b/openpype/hosts/max/plugins/publish/validate_loaded_plugin.py
new file mode 100644
index 0000000000..efa06795b0
--- /dev/null
+++ b/openpype/hosts/max/plugins/publish/validate_loaded_plugin.py
@@ -0,0 +1,133 @@
+# -*- coding: utf-8 -*-
+"""Validator for Loaded Plugin."""
+import os
+import pyblish.api
+from pymxs import runtime as rt
+
+from openpype.pipeline.publish import (
+ RepairAction,
+ OptionalPyblishPluginMixin,
+ PublishValidationError
+)
+from openpype.hosts.max.api.lib import get_plugins
+
+
+class ValidateLoadedPlugin(OptionalPyblishPluginMixin,
+ pyblish.api.InstancePlugin):
+ """Validates if the specific plugin is loaded in 3ds max.
+ Studio Admin(s) can add the plugins they want to check in validation
+ via studio defined project settings
+ """
+
+ order = pyblish.api.ValidatorOrder
+ hosts = ["max"]
+ label = "Validate Loaded Plugins"
+ optional = True
+ actions = [RepairAction]
+
+ family_plugins_mapping = {}
+
+ @classmethod
+ def get_invalid(cls, instance):
+ """Plugin entry point."""
+ family_plugins_mapping = cls.family_plugins_mapping
+ if not family_plugins_mapping:
+ return
+
+ invalid = []
+ # Find all plug-in requirements for current instance
+ instance_families = {instance.data["family"]}
+ instance_families.update(instance.data.get("families", []))
+ cls.log.debug("Checking plug-in validation "
+ f"for instance families: {instance_families}")
+ all_required_plugins = set()
+
+ for mapping in family_plugins_mapping:
+ # Check for matching families
+ if not mapping:
+ return
+
+ match_families = {fam.strip() for fam in mapping["families"]}
+ has_match = "*" in match_families or match_families.intersection(
+ instance_families)
+
+ if not has_match:
+ continue
+
+ cls.log.debug(
+ f"Found plug-in family requirements: {match_families}")
+ required_plugins = [
+ # match lowercase and format with os.environ to allow
+ # plugin names defined by max version, e.g. {3DSMAX_VERSION}
+ plugin.format(**os.environ).lower()
+ for plugin in mapping["plugins"]
+ # ignore empty fields in settings
+ if plugin.strip()
+ ]
+
+ all_required_plugins.update(required_plugins)
+
+ if not all_required_plugins:
+ # Instance has no plug-in requirements
+ return
+
+ # get all DLL loaded plugins in Max and their plugin index
+ available_plugins = {
+ plugin_name.lower(): index for index, plugin_name in enumerate(
+ get_plugins())
+ }
+ # validate the required plug-ins
+ for plugin in sorted(all_required_plugins):
+ plugin_index = available_plugins.get(plugin)
+ if plugin_index is None:
+ debug_msg = (
+ f"Plugin {plugin} does not exist"
+ " in 3dsMax Plugin List."
+ )
+ invalid.append((plugin, debug_msg))
+ continue
+ if not rt.pluginManager.isPluginDllLoaded(plugin_index):
+ debug_msg = f"Plugin {plugin} not loaded."
+ invalid.append((plugin, debug_msg))
+ return invalid
+
+ def process(self, instance):
+ if not self.is_active(instance.data):
+ self.log.debug("Skipping Validate Loaded Plugin...")
+ return
+ invalid = self.get_invalid(instance)
+ if invalid:
+ bullet_point_invalid_statement = "\n".join(
+ "- {}".format(message) for _, message in invalid
+ )
+ report = (
+ "Required plugins are not loaded.\n\n"
+ f"{bullet_point_invalid_statement}\n\n"
+ "You can use repair action to load the plugin."
+ )
+ raise PublishValidationError(
+ report, title="Missing Required Plugins")
+
+ @classmethod
+ def repair(cls, instance):
+ # get all DLL loaded plugins in Max and their plugin index
+ invalid = cls.get_invalid(instance)
+ if not invalid:
+ return
+
+ # get all DLL loaded plugins in Max and their plugin index
+ available_plugins = {
+ plugin_name.lower(): index for index, plugin_name in enumerate(
+ get_plugins())
+ }
+
+ for invalid_plugin, _ in invalid:
+ plugin_index = available_plugins.get(invalid_plugin)
+
+ if plugin_index is None:
+ cls.log.warning(
+ f"Can't enable missing plugin: {invalid_plugin}")
+ continue
+
+ if not rt.pluginManager.isPluginDllLoaded(plugin_index):
+ rt.pluginManager.loadPluginDll(plugin_index)
diff --git a/openpype/hosts/max/plugins/publish/validate_usd_plugin.py b/openpype/hosts/max/plugins/publish/validate_usd_plugin.py
deleted file mode 100644
index 36c4291925..0000000000
--- a/openpype/hosts/max/plugins/publish/validate_usd_plugin.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Validator for USD plugin."""
-from pyblish.api import InstancePlugin, ValidatorOrder
-from pymxs import runtime as rt
-
-from openpype.pipeline import (
- OptionalPyblishPluginMixin,
- PublishValidationError
-)
-
-
-def get_plugins() -> list:
- """Get plugin list from 3ds max."""
- manager = rt.PluginManager
- count = manager.pluginDllCount
- plugin_info_list = []
- for p in range(1, count + 1):
- plugin_info = manager.pluginDllName(p)
- plugin_info_list.append(plugin_info)
-
- return plugin_info_list
-
-
-class ValidateUSDPlugin(OptionalPyblishPluginMixin,
- InstancePlugin):
- """Validates if USD plugin is installed or loaded in 3ds max."""
-
- order = ValidatorOrder - 0.01
- families = ["model"]
- hosts = ["max"]
- label = "Validate USD Plugin loaded"
- optional = True
-
- def process(self, instance):
- """Plugin entry point."""
-
- for sc in ValidateUSDPlugin.__subclasses__():
- self.log.info(sc)
-
- if not self.is_active(instance.data):
- return
-
- plugin_info = get_plugins()
- usd_import = "usdimport.dli"
- if usd_import not in plugin_info:
- raise PublishValidationError(f"USD Plugin {usd_import} not found")
- usd_export = "usdexport.dle"
- if usd_export not in plugin_info:
- raise PublishValidationError(f"USD Plugin {usd_export} not found")
diff --git a/openpype/hosts/maya/api/lib_rendersettings.py b/openpype/hosts/maya/api/lib_rendersettings.py
index 8b57c2e481..1f964589a9 100644
--- a/openpype/hosts/maya/api/lib_rendersettings.py
+++ b/openpype/hosts/maya/api/lib_rendersettings.py
@@ -70,8 +70,8 @@ class RenderSettings(object):
def set_default_renderer_settings(self, renderer=None):
"""Set basic settings based on renderer."""
# Not all hosts can import this module.
- from maya import cmds
- import maya.mel as mel
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
if not renderer:
renderer = cmds.getAttr(
@@ -126,6 +126,10 @@ class RenderSettings(object):
"""Sets settings for Arnold."""
from mtoa.core import createOptions # noqa
from mtoa.aovs import AOVInterface # noqa
+ # Not all hosts can import this module.
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
+
createOptions()
render_settings = self._project_settings["maya"]["RenderSettings"]
arnold_render_presets = render_settings["arnold_renderer"] # noqa
@@ -172,6 +176,10 @@ class RenderSettings(object):
def _set_redshift_settings(self, width, height):
"""Sets settings for Redshift."""
+ # Not all hosts can import this module.
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
+
render_settings = self._project_settings["maya"]["RenderSettings"]
redshift_render_presets = render_settings["redshift_renderer"]
@@ -224,6 +232,10 @@ class RenderSettings(object):
def _set_renderman_settings(self, width, height, aov_separator):
"""Sets settings for Renderman"""
+ # Not all hosts can import this module.
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
+
rman_render_presets = (
self._project_settings
["maya"]
@@ -285,6 +297,11 @@ class RenderSettings(object):
def _set_vray_settings(self, aov_separator, width, height):
# type: (str, int, int) -> None
"""Sets important settings for Vray."""
+ # Not all hosts can import this module.
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
+
+
settings = cmds.ls(type="VRaySettingsNode")
node = settings[0] if settings else cmds.createNode("VRaySettingsNode")
render_settings = self._project_settings["maya"]["RenderSettings"]
@@ -357,6 +374,10 @@ class RenderSettings(object):
@staticmethod
def _set_global_output_settings():
+ # Not all hosts can import this module.
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
+
# enable animation
cmds.setAttr("defaultRenderGlobals.outFormatControl", 0)
cmds.setAttr("defaultRenderGlobals.animation", 1)
@@ -364,6 +385,10 @@ class RenderSettings(object):
cmds.setAttr("defaultRenderGlobals.extensionPadding", 4)
def _additional_attribs_setter(self, additional_attribs):
+ # Not all hosts can import this module.
+ from maya import cmds # noqa: F401
+ import maya.mel as mel # noqa: F401
+
for item in additional_attribs:
attribute, value = item
attribute = str(attribute) # ensure str conversion from settings
diff --git a/openpype/hosts/maya/api/plugin.py b/openpype/hosts/maya/api/plugin.py
index 212c4df492..e684a91fe2 100644
--- a/openpype/hosts/maya/api/plugin.py
+++ b/openpype/hosts/maya/api/plugin.py
@@ -7,6 +7,7 @@ import six
from maya import cmds
from maya.app.renderSetup.model import renderSetup
+from openpype import AYON_SERVER_ENABLED
from openpype.lib import BoolDef, Logger
from openpype.settings import get_project_settings
from openpype.pipeline import (
@@ -449,14 +450,16 @@ class RenderlayerCreator(NewCreator, MayaCreatorBase):
# this instance will not have the `instance_node` data yet
# until it's been saved/persisted at least once.
project_name = self.create_context.get_current_project_name()
-
+ asset_name = self.create_context.get_current_asset_name()
instance_data = {
- "asset": self.create_context.get_current_asset_name(),
"task": self.create_context.get_current_task_name(),
"variant": layer.name(),
}
- asset_doc = get_asset_by_name(project_name,
- instance_data["asset"])
+ if AYON_SERVER_ENABLED:
+ instance_data["folderPath"] = asset_name
+ else:
+ instance_data["asset"] = asset_name
+ asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
layer.name(),
instance_data["task"],
diff --git a/openpype/hosts/maya/plugins/create/create_multishot_layout.py b/openpype/hosts/maya/plugins/create/create_multishot_layout.py
index 0b027c02ea..8f5c423202 100644
--- a/openpype/hosts/maya/plugins/create/create_multishot_layout.py
+++ b/openpype/hosts/maya/plugins/create/create_multishot_layout.py
@@ -45,10 +45,14 @@ class CreateMultishotLayout(plugin.MayaCreator):
above is done.
"""
- current_folder = get_folder_by_name(
- project_name=get_current_project_name(),
- folder_name=get_current_asset_name(),
- )
+ project_name = get_current_project_name()
+ folder_path = get_current_asset_name()
+ if "/" in folder_path:
+ current_folder = get_folder_by_path(project_name, folder_path)
+ else:
+ current_folder = get_folder_by_name(
+ project_name, folder_name=folder_path
+ )
current_path_parts = current_folder["path"].split("/")
@@ -154,7 +158,7 @@ class CreateMultishotLayout(plugin.MayaCreator):
# Create layout instance by the layout creator
instance_data = {
- "asset": shot["name"],
+ "folderPath": shot["path"],
"variant": layout_creator.get_default_variant()
}
if layout_task:
diff --git a/openpype/hosts/maya/plugins/create/create_review.py b/openpype/hosts/maya/plugins/create/create_review.py
index f60e2406bc..18d661b186 100644
--- a/openpype/hosts/maya/plugins/create/create_review.py
+++ b/openpype/hosts/maya/plugins/create/create_review.py
@@ -2,6 +2,7 @@ import json
from maya import cmds
+from openpype import AYON_SERVER_ENABLED
from openpype.hosts.maya.api import (
lib,
plugin
@@ -43,7 +44,11 @@ class CreateReview(plugin.MayaCreator):
members = cmds.ls(selection=True)
project_name = self.project_name
- asset_doc = get_asset_by_name(project_name, instance_data["asset"])
+ if AYON_SERVER_ENABLED:
+ asset_name = instance_data["folderPath"]
+ else:
+ asset_name = instance_data["asset"]
+ asset_doc = get_asset_by_name(project_name, asset_name)
task_name = instance_data["task"]
preset = lib.get_capture_preset(
task_name,
diff --git a/openpype/hosts/maya/plugins/create/create_unreal_skeletalmesh.py b/openpype/hosts/maya/plugins/create/create_unreal_skeletalmesh.py
index 3c9a79156a..b4151bac99 100644
--- a/openpype/hosts/maya/plugins/create/create_unreal_skeletalmesh.py
+++ b/openpype/hosts/maya/plugins/create/create_unreal_skeletalmesh.py
@@ -51,7 +51,7 @@ class CreateUnrealSkeletalMesh(plugin.MayaCreator):
# We reorganize the geometry that was originally added into the
# set into either 'joints_SET' or 'geometry_SET' based on the
# joint_hints from project settings
- members = cmds.sets(instance_node, query=True)
+ members = cmds.sets(instance_node, query=True) or []
cmds.sets(clear=instance_node)
geometry_set = cmds.sets(name="geometry_SET", empty=True)
diff --git a/openpype/hosts/maya/plugins/create/create_workfile.py b/openpype/hosts/maya/plugins/create/create_workfile.py
index d84753cd7f..198f9c4a36 100644
--- a/openpype/hosts/maya/plugins/create/create_workfile.py
+++ b/openpype/hosts/maya/plugins/create/create_workfile.py
@@ -1,7 +1,8 @@
# -*- coding: utf-8 -*-
"""Creator plugin for creating workfiles."""
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline import CreatedInstance, AutoCreator
-from openpype.client import get_asset_by_name
+from openpype.client import get_asset_by_name, get_asset_name_identifier
from openpype.hosts.maya.api import plugin
from maya import cmds
@@ -29,16 +30,27 @@ class CreateWorkfile(plugin.MayaCreatorBase, AutoCreator):
task_name = self.create_context.get_current_task_name()
host_name = self.create_context.host_name
+ if current_instance is None:
+ current_instance_asset = None
+ elif AYON_SERVER_ENABLED:
+ current_instance_asset = current_instance["folderPath"]
+ else:
+ current_instance_asset = current_instance["asset"]
+
if current_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
variant, task_name, asset_doc, project_name, host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
+
data.update(
self.get_dynamic_data(
variant, task_name, asset_doc,
@@ -50,15 +62,20 @@ class CreateWorkfile(plugin.MayaCreatorBase, AutoCreator):
)
self._add_instance_to_context(current_instance)
elif (
- current_instance["asset"] != asset_name
- or current_instance["task"] != task_name
+ current_instance_asset != asset_name
+ or current_instance["task"] != task_name
):
# Update instance context if is not the same
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
variant, task_name, asset_doc, project_name, host_name
)
- current_instance["asset"] = asset_name
+ asset_name = get_asset_name_identifier(asset_doc)
+
+ if AYON_SERVER_ENABLED:
+ current_instance["folderPath"] = asset_name
+ else:
+ current_instance["asset"] = asset_name
current_instance["task"] = task_name
current_instance["subset"] = subset_name
diff --git a/openpype/hosts/maya/plugins/publish/collect_review.py b/openpype/hosts/maya/plugins/publish/collect_review.py
index 586939a3b8..0930da8f27 100644
--- a/openpype/hosts/maya/plugins/publish/collect_review.py
+++ b/openpype/hosts/maya/plugins/publish/collect_review.py
@@ -3,7 +3,7 @@ from maya import cmds, mel
import pyblish.api
from openpype.client import get_subset_by_name
-from openpype.pipeline import legacy_io, KnownPublishError
+from openpype.pipeline import KnownPublishError
from openpype.hosts.maya.api import lib
@@ -116,10 +116,10 @@ class CollectReview(pyblish.api.InstancePlugin):
instance.data['remove'] = True
else:
- task = legacy_io.Session["AVALON_TASK"]
- legacy_subset_name = task + 'Review'
+ project_name = instance.context.data["projectName"]
asset_doc = instance.context.data['assetEntity']
- project_name = legacy_io.active_project()
+ task = instance.context.data["task"]
+ legacy_subset_name = task + 'Review'
subset_doc = get_subset_by_name(
project_name,
legacy_subset_name,
diff --git a/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_abc.py b/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_abc.py
index 9c2f55a1ef..780ed2377c 100644
--- a/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_abc.py
+++ b/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_abc.py
@@ -13,16 +13,6 @@ from openpype.hosts.maya.api.lib import (
)
-@contextmanager
-def renamed(original_name, renamed_name):
- # type: (str, str) -> None
- try:
- cmds.rename(original_name, renamed_name)
- yield
- finally:
- cmds.rename(renamed_name, original_name)
-
-
class ExtractUnrealSkeletalMeshAbc(publish.Extractor):
"""Extract Unreal Skeletal Mesh as FBX from Maya. """
diff --git a/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_fbx.py b/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_fbx.py
index 96175a07d7..4b36134694 100644
--- a/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_fbx.py
+++ b/openpype/hosts/maya/plugins/publish/extract_unreal_skeletalmesh_fbx.py
@@ -62,6 +62,10 @@ class ExtractUnrealSkeletalMeshFbx(publish.Extractor):
original_parent = to_extract[0].split("|")[1]
parent_node = instance.data.get("asset")
+ # this needs to be done for AYON
+ # WARNING: since AYON supports duplicity of asset names,
+ # this needs to be refactored throughout the pipeline.
+ parent_node = parent_node.split("/")[-1]
renamed_to_extract = []
for node in to_extract:
diff --git a/openpype/hosts/maya/plugins/publish/validate_instance_in_context.py b/openpype/hosts/maya/plugins/publish/validate_instance_in_context.py
index 4ded57137c..4222e63898 100644
--- a/openpype/hosts/maya/plugins/publish/validate_instance_in_context.py
+++ b/openpype/hosts/maya/plugins/publish/validate_instance_in_context.py
@@ -3,6 +3,7 @@
from __future__ import absolute_import
import pyblish.api
+from openpype import AYON_SERVER_ENABLED
import openpype.hosts.maya.api.action
from openpype.pipeline.publish import (
RepairAction,
@@ -66,12 +67,16 @@ class ValidateInstanceInContext(pyblish.api.InstancePlugin,
def repair(cls, instance):
context_asset = cls.get_context_asset(instance)
instance_node = instance.data["instance_node"]
+ if AYON_SERVER_ENABLED:
+ asset_name_attr = "folderPath"
+ else:
+ asset_name_attr = "asset"
cmds.setAttr(
- "{}.asset".format(instance_node),
+ "{}.{}".format(instance_node, asset_name_attr),
context_asset,
type="string"
)
@staticmethod
def get_context_asset(instance):
- return instance.context.data["assetEntity"]["name"]
+ return instance.context.data["asset"]
diff --git a/openpype/hosts/maya/plugins/publish/validate_model_name.py b/openpype/hosts/maya/plugins/publish/validate_model_name.py
index f4c1aa39c7..11f59bb439 100644
--- a/openpype/hosts/maya/plugins/publish/validate_model_name.py
+++ b/openpype/hosts/maya/plugins/publish/validate_model_name.py
@@ -67,13 +67,15 @@ class ValidateModelName(pyblish.api.InstancePlugin,
regex = cls.top_level_regex
r = re.compile(regex)
m = r.match(top_group)
+ project_name = instance.context.data["projectName"]
+ current_asset_name = instance.context.data["asset"]
if m is None:
cls.log.error("invalid name on: {}".format(top_group))
cls.log.error("name doesn't match regex {}".format(regex))
invalid.append(top_group)
else:
if "asset" in r.groupindex:
- if m.group("asset") != legacy_io.Session["AVALON_ASSET"]:
+ if m.group("asset") != current_asset_name:
cls.log.error("Invalid asset name in top level group.")
return top_group
if "subset" in r.groupindex:
@@ -81,7 +83,7 @@ class ValidateModelName(pyblish.api.InstancePlugin,
cls.log.error("Invalid subset name in top level group.")
return top_group
if "project" in r.groupindex:
- if m.group("project") != legacy_io.Session["AVALON_PROJECT"]:
+ if m.group("project") != project_name:
cls.log.error("Invalid project name in top level group.")
return top_group
diff --git a/openpype/hosts/maya/plugins/publish/validate_shader_name.py b/openpype/hosts/maya/plugins/publish/validate_shader_name.py
index 36bb2c1fee..d6486dea7f 100644
--- a/openpype/hosts/maya/plugins/publish/validate_shader_name.py
+++ b/openpype/hosts/maya/plugins/publish/validate_shader_name.py
@@ -51,7 +51,7 @@ class ValidateShaderName(pyblish.api.InstancePlugin,
descendants = cmds.ls(descendants, noIntermediate=True, long=True)
shapes = cmds.ls(descendants, type=["nurbsSurface", "mesh"], long=True)
- asset_name = instance.data.get("asset", None)
+ asset_name = instance.data.get("asset")
# Check the number of connected shadingEngines per shape
regex_compile = re.compile(cls.regex)
diff --git a/openpype/hosts/maya/plugins/publish/validate_unreal_staticmesh_naming.py b/openpype/hosts/maya/plugins/publish/validate_unreal_staticmesh_naming.py
index 58fa9d02bd..42d3dc3ac8 100644
--- a/openpype/hosts/maya/plugins/publish/validate_unreal_staticmesh_naming.py
+++ b/openpype/hosts/maya/plugins/publish/validate_unreal_staticmesh_naming.py
@@ -102,7 +102,8 @@ class ValidateUnrealStaticMeshName(pyblish.api.InstancePlugin,
cl_r = re.compile(regex_collision)
- mesh_name = "{}{}".format(instance.data["asset"],
+ asset_name = instance.data["assetEntity"]["name"]
+ mesh_name = "{}{}".format(asset_name,
instance.data.get("variant", []))
for obj in collision_set:
diff --git a/openpype/hosts/maya/tools/mayalookassigner/commands.py b/openpype/hosts/maya/tools/mayalookassigner/commands.py
index 5cc4f84931..86df502ecd 100644
--- a/openpype/hosts/maya/tools/mayalookassigner/commands.py
+++ b/openpype/hosts/maya/tools/mayalookassigner/commands.py
@@ -4,7 +4,7 @@ from collections import defaultdict
import maya.cmds as cmds
-from openpype.client import get_assets
+from openpype.client import get_assets, get_asset_name_identifier
from openpype.pipeline import (
remove_container,
registered_host,
@@ -128,7 +128,8 @@ def create_items_from_nodes(nodes):
project_name = get_current_project_name()
asset_ids = set(id_hashes.keys())
- asset_docs = get_assets(project_name, asset_ids, fields=["name"])
+ fields = {"_id", "name", "data.parents"}
+ asset_docs = get_assets(project_name, asset_ids, fields=fields)
asset_docs_by_id = {
str(asset_doc["_id"]): asset_doc
for asset_doc in asset_docs
@@ -156,8 +157,9 @@ def create_items_from_nodes(nodes):
namespace = get_namespace_from_node(node)
namespaces.add(namespace)
+ label = get_asset_name_identifier(asset_doc)
asset_view_items.append({
- "label": asset_doc["name"],
+ "label": label,
"asset": asset_doc,
"looks": looks,
"namespaces": namespaces
diff --git a/openpype/hosts/maya/tools/mayalookassigner/widgets.py b/openpype/hosts/maya/tools/mayalookassigner/widgets.py
index 82c37e2104..ef29a4c726 100644
--- a/openpype/hosts/maya/tools/mayalookassigner/widgets.py
+++ b/openpype/hosts/maya/tools/mayalookassigner/widgets.py
@@ -3,6 +3,7 @@ from collections import defaultdict
from qtpy import QtWidgets, QtCore
+from openpype.client import get_asset_name_identifier
from openpype.tools.utils.models import TreeModel
from openpype.tools.utils.lib import (
preserve_expanded_rows,
@@ -126,7 +127,7 @@ class AssetOutliner(QtWidgets.QWidget):
asset_namespaces = defaultdict(set)
for item in items:
asset_id = str(item["asset"]["_id"])
- asset_name = item["asset"]["name"]
+ asset_name = get_asset_name_identifier(item["asset"])
asset_namespaces[asset_name].add(item.get("namespace"))
if asset_name in assets:
diff --git a/openpype/hosts/nuke/api/lib.py b/openpype/hosts/nuke/api/lib.py
index 8b1ba0ab0d..88c587faf6 100644
--- a/openpype/hosts/nuke/api/lib.py
+++ b/openpype/hosts/nuke/api/lib.py
@@ -13,6 +13,7 @@ from collections import OrderedDict
import nuke
from qtpy import QtCore, QtWidgets
+from openpype import AYON_SERVER_ENABLED
from openpype.client import (
get_project,
get_asset_by_name,
@@ -120,7 +121,7 @@ def deprecated(new_destination):
class Context:
main_window = None
- context_label = None
+ context_action_item = None
project_name = os.getenv("AVALON_PROJECT")
# Workfile related code
workfiles_launched = False
@@ -1107,7 +1108,9 @@ def format_anatomy(data):
Return:
path (str)
'''
- anatomy = Anatomy()
+
+ project_name = get_current_project_name()
+ anatomy = Anatomy(project_name)
log.debug("__ anatomy.templates: {}".format(anatomy.templates))
padding = None
@@ -1125,8 +1128,10 @@ def format_anatomy(data):
file = script_name()
data["version"] = get_version_from_path(file)
- project_name = anatomy.project_name
- asset_name = data["asset"]
+ if AYON_SERVER_ENABLED:
+ asset_name = data["folderPath"]
+ else:
+ asset_name = data["asset"]
task_name = data["task"]
host_name = get_current_host_name()
context_data = get_template_data_with_names(
diff --git a/openpype/hosts/nuke/api/pipeline.py b/openpype/hosts/nuke/api/pipeline.py
index ba4d66ab63..7bc17ff504 100644
--- a/openpype/hosts/nuke/api/pipeline.py
+++ b/openpype/hosts/nuke/api/pipeline.py
@@ -236,9 +236,13 @@ def _install_menu():
if not ASSIST:
label = get_context_label()
- Context.context_label = label
- context_action = menu.addCommand(label)
- context_action.setEnabled(False)
+ context_action_item = menu.addCommand("Context")
+ context_action_item.setEnabled(False)
+
+ Context.context_action_item = context_action_item
+
+ context_action = context_action_item.action()
+ context_action.setText(label)
# add separator after context label
menu.addSeparator()
@@ -348,26 +352,21 @@ def _install_menu():
def change_context_label():
- menubar = nuke.menu("Nuke")
- menu = menubar.findItem(MENU_LABEL)
+ if ASSIST:
+ return
- label = get_context_label()
+ context_action_item = Context.context_action_item
+ if context_action_item is None:
+ return
+ context_action = context_action_item.action()
- rm_item = [
- (i, item) for i, item in enumerate(menu.items())
- if Context.context_label in item.name()
- ][0]
+ old_label = context_action.text()
+ new_label = get_context_label()
- menu.removeItem(rm_item[1].name())
-
- context_action = menu.addCommand(
- label,
- index=(rm_item[0])
- )
- context_action.setEnabled(False)
+ context_action.setText(new_label)
log.info("Task label changed from `{}` to `{}`".format(
- Context.context_label, label))
+ old_label, new_label))
def add_shortcuts_from_presets():
diff --git a/openpype/hosts/photoshop/lib.py b/openpype/hosts/photoshop/lib.py
index 9f603a70d2..5c8dff947d 100644
--- a/openpype/hosts/photoshop/lib.py
+++ b/openpype/hosts/photoshop/lib.py
@@ -1,5 +1,6 @@
import re
+from openpype import AYON_SERVER_ENABLED
import openpype.hosts.photoshop.api as api
from openpype.client import get_asset_by_name
from openpype.lib import prepare_template_data
@@ -43,6 +44,14 @@ class PSAutoCreator(AutoCreator):
asset_name = context.get_current_asset_name()
task_name = context.get_current_task_name()
host_name = context.host_name
+
+ if existing_instance is None:
+ existing_instance_asset = None
+ elif AYON_SERVER_ENABLED:
+ existing_instance_asset = existing_instance["folderPath"]
+ else:
+ existing_instance_asset = existing_instance["asset"]
+
if existing_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
@@ -50,10 +59,13 @@ class PSAutoCreator(AutoCreator):
project_name, host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": self.default_variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
data.update(self.get_dynamic_data(
self.default_variant, task_name, asset_doc,
project_name, host_name, None
@@ -70,7 +82,7 @@ class PSAutoCreator(AutoCreator):
new_instance.data_to_store())
elif (
- existing_instance["asset"] != asset_name
+ existing_instance_asset != asset_name
or existing_instance["task"] != task_name
):
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -78,7 +90,10 @@ class PSAutoCreator(AutoCreator):
self.default_variant, task_name, asset_doc,
project_name, host_name
)
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/photoshop/plugins/create/create_flatten_image.py b/openpype/hosts/photoshop/plugins/create/create_flatten_image.py
index afde77fdb4..24be9df0e0 100644
--- a/openpype/hosts/photoshop/plugins/create/create_flatten_image.py
+++ b/openpype/hosts/photoshop/plugins/create/create_flatten_image.py
@@ -1,5 +1,6 @@
from openpype.pipeline import CreatedInstance
+from openpype import AYON_SERVER_ENABLED
from openpype.lib import BoolDef
import openpype.hosts.photoshop.api as api
from openpype.hosts.photoshop.lib import PSAutoCreator, clean_subset_name
@@ -37,6 +38,13 @@ class AutoImageCreator(PSAutoCreator):
host_name = context.host_name
asset_doc = get_asset_by_name(project_name, asset_name)
+ if existing_instance is None:
+ existing_instance_asset = None
+ elif AYON_SERVER_ENABLED:
+ existing_instance_asset = existing_instance["folderPath"]
+ else:
+ existing_instance_asset = existing_instance["asset"]
+
if existing_instance is None:
subset_name = self.get_subset_name(
self.default_variant, task_name, asset_doc,
@@ -44,9 +52,12 @@ class AutoImageCreator(PSAutoCreator):
)
data = {
- "asset": asset_name,
"task": task_name,
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
if not self.active_on_create:
data["active"] = False
@@ -62,15 +73,17 @@ class AutoImageCreator(PSAutoCreator):
new_instance.data_to_store())
elif ( # existing instance from different context
- existing_instance["asset"] != asset_name
+ existing_instance_asset != asset_name
or existing_instance["task"] != task_name
):
subset_name = self.get_subset_name(
self.default_variant, task_name, asset_doc,
project_name, host_name
)
-
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/photoshop/plugins/publish/collect_auto_image.py b/openpype/hosts/photoshop/plugins/publish/collect_auto_image.py
index 77f1a3e91f..4d7838c510 100644
--- a/openpype/hosts/photoshop/plugins/publish/collect_auto_image.py
+++ b/openpype/hosts/photoshop/plugins/publish/collect_auto_image.py
@@ -1,5 +1,6 @@
import pyblish.api
+from openpype.client import get_asset_name_identifier
from openpype.hosts.photoshop import api as photoshop
from openpype.pipeline.create import get_subset_name
@@ -22,12 +23,12 @@ class CollectAutoImage(pyblish.api.ContextPlugin):
self.log.debug("Auto image instance found, won't create new")
return
- project_name = context.data["anatomyData"]["project"]["name"]
+ project_name = context.data["projectName"]
proj_settings = context.data["project_settings"]
- task_name = context.data["anatomyData"]["task"]["name"]
+ task_name = context.data["task"]
host_name = context.data["hostName"]
asset_doc = context.data["assetEntity"]
- asset_name = asset_doc["name"]
+ asset_name = get_asset_name_identifier(asset_doc)
auto_creator = proj_settings.get(
"photoshop", {}).get(
diff --git a/openpype/hosts/photoshop/plugins/publish/collect_auto_review.py b/openpype/hosts/photoshop/plugins/publish/collect_auto_review.py
index 82ba0ac09c..e5a2f326d7 100644
--- a/openpype/hosts/photoshop/plugins/publish/collect_auto_review.py
+++ b/openpype/hosts/photoshop/plugins/publish/collect_auto_review.py
@@ -7,6 +7,7 @@ Provides:
"""
import pyblish.api
+from openpype.client import get_asset_name_identifier
from openpype.hosts.photoshop import api as photoshop
from openpype.pipeline.create import get_subset_name
@@ -60,12 +61,13 @@ class CollectAutoReview(pyblish.api.ContextPlugin):
variant = (context.data.get("variant") or
auto_creator["default_variant"])
- project_name = context.data["anatomyData"]["project"]["name"]
+ project_name = context.data["projectName"]
proj_settings = context.data["project_settings"]
- task_name = context.data["anatomyData"]["task"]["name"]
+ task_name = context.data["task"]
host_name = context.data["hostName"]
asset_doc = context.data["assetEntity"]
- asset_name = asset_doc["name"]
+
+ asset_name = get_asset_name_identifier(asset_doc)
subset_name = get_subset_name(
family,
diff --git a/openpype/hosts/photoshop/plugins/publish/collect_auto_workfile.py b/openpype/hosts/photoshop/plugins/publish/collect_auto_workfile.py
index 01dc50af40..9ccb8f4f85 100644
--- a/openpype/hosts/photoshop/plugins/publish/collect_auto_workfile.py
+++ b/openpype/hosts/photoshop/plugins/publish/collect_auto_workfile.py
@@ -1,6 +1,7 @@
import os
import pyblish.api
+from openpype.client import get_asset_name_identifier
from openpype.hosts.photoshop import api as photoshop
from openpype.pipeline.create import get_subset_name
@@ -51,7 +52,7 @@ class CollectAutoWorkfile(pyblish.api.ContextPlugin):
self.log.debug("Workfile instance disabled")
return
- project_name = context.data["anatomyData"]["project"]["name"]
+ project_name = context.data["projectName"]
proj_settings = context.data["project_settings"]
auto_creator = proj_settings.get(
"photoshop", {}).get(
@@ -66,11 +67,11 @@ class CollectAutoWorkfile(pyblish.api.ContextPlugin):
variant = (context.data.get("variant") or
auto_creator["default_variant"])
- task_name = context.data["anatomyData"]["task"]["name"]
+ task_name = context.data["task"]
host_name = context.data["hostName"]
asset_doc = context.data["assetEntity"]
- asset_name = asset_doc["name"]
+ asset_name = get_asset_name_identifier(asset_doc)
subset_name = get_subset_name(
family,
variant,
diff --git a/openpype/hosts/resolve/api/plugin.py b/openpype/hosts/resolve/api/plugin.py
index 5c4a92df89..197f288150 100644
--- a/openpype/hosts/resolve/api/plugin.py
+++ b/openpype/hosts/resolve/api/plugin.py
@@ -1,10 +1,11 @@
import re
import uuid
+import copy
+
import qargparse
from qtpy import QtWidgets, QtCore
from openpype.settings import get_current_project_settings
-from openpype.pipeline.context_tools import get_current_project_asset
from openpype.pipeline import (
LegacyCreator,
LoaderPlugin,
@@ -18,7 +19,7 @@ from .menu import load_stylesheet
class CreatorWidget(QtWidgets.QDialog):
# output items
- items = dict()
+ items = {}
def __init__(self, name, info, ui_inputs, parent=None):
super(CreatorWidget, self).__init__(parent)
@@ -100,7 +101,7 @@ class CreatorWidget(QtWidgets.QDialog):
self.close()
def value(self, data, new_data=None):
- new_data = new_data or dict()
+ new_data = new_data or {}
for k, v in data.items():
new_data[k] = {
"target": None,
@@ -289,7 +290,7 @@ class Spacer(QtWidgets.QWidget):
class ClipLoader:
active_bin = None
- data = dict()
+ data = {}
def __init__(self, loader_obj, context, **options):
""" Initialize object
@@ -386,8 +387,8 @@ class ClipLoader:
joint `data` key with asset.data dict into the representation
"""
- asset_name = self.context["representation"]["context"]["asset"]
- self.data["assetData"] = get_current_project_asset(asset_name)["data"]
+
+ self.data["assetData"] = copy.deepcopy(self.context["asset"]["data"])
def load(self, files):
"""Load clip into timeline
@@ -587,8 +588,8 @@ class PublishClip:
Returns:
hiero.core.TrackItem: hiero track item object with openpype tag
"""
- vertical_clip_match = dict()
- tag_data = dict()
+ vertical_clip_match = {}
+ tag_data = {}
types = {
"shot": "shot",
"folder": "folder",
@@ -664,15 +665,23 @@ class PublishClip:
new_name = self.tag_data.pop("newClipName")
if self.rename:
- self.tag_data["asset"] = new_name
+ self.tag_data["asset_name"] = new_name
else:
- self.tag_data["asset"] = self.ti_name
+ self.tag_data["asset_name"] = self.ti_name
+ # AYON unique identifier
+ folder_path = "/{}/{}".format(
+ self.tag_data["hierarchy"],
+ self.tag_data["asset_name"]
+ )
+ self.tag_data["folder_path"] = folder_path
+
+ # create new name for track item
if not lib.pype_marker_workflow:
# create compound clip workflow
lib.create_compound_clip(
self.timeline_item_data,
- self.tag_data["asset"],
+ self.tag_data["asset_name"],
self.mp_folder
)
@@ -764,7 +773,7 @@ class PublishClip:
# increasing steps by index of rename iteration
self.count_steps *= self.rename_index
- hierarchy_formatting_data = dict()
+ hierarchy_formatting_data = {}
_data = self.timeline_item_default_data.copy()
if self.ui_inputs:
# adding tag metadata from ui
@@ -853,8 +862,7 @@ class PublishClip:
"parents": self.parents,
"hierarchyData": hierarchy_formatting_data,
"subset": self.subset,
- "family": self.subset_family,
- "families": ["clip"]
+ "family": self.subset_family
}
def _convert_to_entity(self, key):
diff --git a/openpype/hosts/resolve/plugins/publish/extract_workfile.py b/openpype/hosts/resolve/plugins/publish/extract_workfile.py
index 535f879b58..db63487405 100644
--- a/openpype/hosts/resolve/plugins/publish/extract_workfile.py
+++ b/openpype/hosts/resolve/plugins/publish/extract_workfile.py
@@ -26,6 +26,7 @@ class ExtractWorkfile(publish.Extractor):
resolve_workfile_ext = ".drp"
drp_file_name = name + resolve_workfile_ext
+
drp_file_path = os.path.normpath(
os.path.join(staging_dir, drp_file_name))
diff --git a/openpype/hosts/resolve/plugins/publish/precollect_instances.py b/openpype/hosts/resolve/plugins/publish/precollect_instances.py
index 8ec169ad65..bca6734848 100644
--- a/openpype/hosts/resolve/plugins/publish/precollect_instances.py
+++ b/openpype/hosts/resolve/plugins/publish/precollect_instances.py
@@ -9,6 +9,7 @@ from openpype.hosts.resolve.api.lib import (
get_publish_attribute,
get_otio_clip_instance_data,
)
+from openpype import AYON_SERVER_ENABLED
class PrecollectInstances(pyblish.api.ContextPlugin):
@@ -29,7 +30,7 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
for timeline_item_data in selected_timeline_items:
- data = dict()
+ data = {}
timeline_item = timeline_item_data["clip"]["item"]
# get pype tag data
@@ -60,24 +61,24 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
if k not in ("id", "applieswhole", "label")
})
- asset = tag_data["asset"]
+ if AYON_SERVER_ENABLED:
+ asset = tag_data["folder_path"]
+ else:
+ asset = tag_data["asset_name"]
+
subset = tag_data["subset"]
- # insert family into families
- family = tag_data["family"]
- families = [str(f) for f in tag_data["families"]]
- families.insert(0, str(family))
-
data.update({
- "name": "{} {} {}".format(asset, subset, families),
+ "name": "{}_{}".format(asset, subset),
+ "label": "{} {}".format(asset, subset),
"asset": asset,
"item": timeline_item,
- "families": families,
"publish": get_publish_attribute(timeline_item),
"fps": context.data["fps"],
"handleStart": handle_start,
"handleEnd": handle_end,
- "newAssetPublishing": True
+ "newAssetPublishing": True,
+ "families": ["clip"],
})
# otio clip data
@@ -135,7 +136,8 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
family = "shot"
data.update({
- "name": "{} {} {}".format(asset, subset, family),
+ "name": "{}_{}".format(asset, subset),
+ "label": "{} {}".format(asset, subset),
"subset": subset,
"asset": asset,
"family": family,
diff --git a/openpype/hosts/resolve/plugins/publish/precollect_workfile.py b/openpype/hosts/resolve/plugins/publish/precollect_workfile.py
index a2f3eaed7a..ccc5fd86ff 100644
--- a/openpype/hosts/resolve/plugins/publish/precollect_workfile.py
+++ b/openpype/hosts/resolve/plugins/publish/precollect_workfile.py
@@ -1,7 +1,9 @@
import pyblish.api
from pprint import pformat
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline import get_current_asset_name
+
from openpype.hosts.resolve import api as rapi
from openpype.hosts.resolve.otio import davinci_export
@@ -13,9 +15,12 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
order = pyblish.api.CollectorOrder - 0.5
def process(self, context):
+ current_asset_name = asset_name = get_current_asset_name()
- asset = get_current_asset_name()
- subset = "workfile"
+ if AYON_SERVER_ENABLED:
+ asset_name = current_asset_name.split("/")[-1]
+
+ subset = "workfileMain"
project = rapi.get_current_project()
fps = project.GetSetting("timelineFrameRate")
video_tracks = rapi.get_video_track_names()
@@ -24,9 +29,10 @@ class PrecollectWorkfile(pyblish.api.ContextPlugin):
otio_timeline = davinci_export.create_otio_timeline(project)
instance_data = {
- "name": "{}_{}".format(asset, subset),
- "asset": asset,
- "subset": "{}{}".format(asset, subset.capitalize()),
+ "name": "{}_{}".format(asset_name, subset),
+ "label": "{} {}".format(current_asset_name, subset),
+ "asset": current_asset_name,
+ "subset": subset,
"item": project,
"family": "workfile",
"families": []
diff --git a/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_scenes.py b/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_scenes.py
index 48c36aa067..c435ca2096 100644
--- a/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_scenes.py
+++ b/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_scenes.py
@@ -60,6 +60,9 @@ class CollectHarmonyScenes(pyblish.api.InstancePlugin):
# updating hierarchy data
anatomy_data_new.update({
"asset": asset_data["name"],
+ "folder": {
+ "name": asset_data["name"],
+ },
"task": {
"name": task,
"type": task_type,
diff --git a/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_zips.py b/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_zips.py
index 40a969f8df..d90215e767 100644
--- a/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_zips.py
+++ b/openpype/hosts/standalonepublisher/plugins/publish/collect_harmony_zips.py
@@ -56,6 +56,9 @@ class CollectHarmonyZips(pyblish.api.InstancePlugin):
anatomy_data_new.update(
{
"asset": asset_data["name"],
+ "folder": {
+ "name": asset_data["name"],
+ },
"task": {
"name": task,
"type": task_type,
diff --git a/openpype/hosts/substancepainter/api/pipeline.py b/openpype/hosts/substancepainter/api/pipeline.py
index e96064b2bf..a13075127f 100644
--- a/openpype/hosts/substancepainter/api/pipeline.py
+++ b/openpype/hosts/substancepainter/api/pipeline.py
@@ -170,7 +170,8 @@ class SubstanceHost(HostBase, IWorkfileHost, ILoadHost, IPublishHost):
parent = substance_painter.ui.get_main_window()
- menu = QtWidgets.QMenu("OpenPype")
+ tab_menu_label = os.environ.get("AVALON_LABEL") or "AYON"
+ menu = QtWidgets.QMenu(tab_menu_label)
action = menu.addAction("Create...")
action.triggered.connect(
diff --git a/openpype/hosts/substancepainter/plugins/create/create_workfile.py b/openpype/hosts/substancepainter/plugins/create/create_workfile.py
index d7f31f9dcf..c73277e405 100644
--- a/openpype/hosts/substancepainter/plugins/create/create_workfile.py
+++ b/openpype/hosts/substancepainter/plugins/create/create_workfile.py
@@ -1,6 +1,7 @@
# -*- coding: utf-8 -*-
"""Creator plugin for creating workfiles."""
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline import CreatedInstance, AutoCreator
from openpype.client import get_asset_by_name
@@ -41,6 +42,13 @@ class CreateWorkfile(AutoCreator):
if instance.creator_identifier == self.identifier
), None)
+ if current_instance is None:
+ current_instance_asset = None
+ elif AYON_SERVER_ENABLED:
+ current_instance_asset = current_instance["folderPath"]
+ else:
+ current_instance_asset = current_instance["asset"]
+
if current_instance is None:
self.log.info("Auto-creating workfile instance...")
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -48,22 +56,28 @@ class CreateWorkfile(AutoCreator):
variant, task_name, asset_doc, project_name, host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
current_instance = self.create_instance_in_context(subset_name,
data)
elif (
- current_instance["asset"] != asset_name
- or current_instance["task"] != task_name
+ current_instance_asset != asset_name
+ or current_instance["task"] != task_name
):
# Update instance context if is not the same
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
variant, task_name, asset_doc, project_name, host_name
)
- current_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ current_instance["folderPath"] = asset_name
+ else:
+ current_instance["asset"] = asset_name
current_instance["task"] = task_name
current_instance["subset"] = subset_name
diff --git a/openpype/hosts/traypublisher/api/editorial.py b/openpype/hosts/traypublisher/api/editorial.py
index e8f76bd314..613f1de768 100644
--- a/openpype/hosts/traypublisher/api/editorial.py
+++ b/openpype/hosts/traypublisher/api/editorial.py
@@ -53,11 +53,11 @@ class ShotMetadataSolver:
try:
# format to new shot name
return shot_rename_template.format(**data)
- except KeyError as _E:
+ except KeyError as _error:
raise CreatorError((
"Make sure all keys in settings are correct:: \n\n"
f"From template string {shot_rename_template} > "
- f"`{_E}` has no equivalent in \n"
+ f"`{_error}` has no equivalent in \n"
f"{list(data.keys())} input formatting keys!"
))
@@ -100,7 +100,7 @@ class ShotMetadataSolver:
"at your project settings..."
))
- # QUESTION:how to refactory `match[-1]` to some better way?
+ # QUESTION:how to refactor `match[-1]` to some better way?
output_data[token_key] = match[-1]
return output_data
@@ -130,10 +130,10 @@ class ShotMetadataSolver:
parent_token["name"]: parent_token["value"].format(**data)
for parent_token in hierarchy_parents
}
- except KeyError as _E:
+ except KeyError as _error:
raise CreatorError((
"Make sure all keys in settings are correct : \n"
- f"`{_E}` has no equivalent in \n{list(data.keys())}"
+ f"`{_error}` has no equivalent in \n{list(data.keys())}"
))
_parent_tokens_type = {
@@ -147,10 +147,10 @@ class ShotMetadataSolver:
try:
parent_name = _parent.format(
**_parent_tokens_formatting_data)
- except KeyError as _E:
+ except KeyError as _error:
raise CreatorError((
"Make sure all keys in settings are correct : \n\n"
- f"`{_E}` from template string "
+ f"`{_error}` from template string "
f"{shot_hierarchy['parents_path']}, "
f" has no equivalent in \n"
f"{list(_parent_tokens_formatting_data.keys())} parents"
@@ -319,8 +319,16 @@ class ShotMetadataSolver:
tasks = self._generate_tasks_from_settings(
project_doc)
+ # generate hierarchy path from parents
+ hierarchy_path = self._create_hierarchy_path(parents)
+ if hierarchy_path:
+ folder_path = f"/{hierarchy_path}/{shot_name}"
+ else:
+ folder_path = f"/{shot_name}"
+
return shot_name, {
- "hierarchy": self._create_hierarchy_path(parents),
+ "hierarchy": hierarchy_path,
+ "folderPath": folder_path,
"parents": parents,
"tasks": tasks
}
diff --git a/openpype/hosts/traypublisher/api/plugin.py b/openpype/hosts/traypublisher/api/plugin.py
index 36e041a32c..14c66fa08f 100644
--- a/openpype/hosts/traypublisher/api/plugin.py
+++ b/openpype/hosts/traypublisher/api/plugin.py
@@ -1,7 +1,9 @@
+from openpype import AYON_SERVER_ENABLED
from openpype.client import (
get_assets,
get_subsets,
get_last_versions,
+ get_asset_name_identifier,
)
from openpype.lib.attribute_definitions import (
FileDef,
@@ -114,7 +116,10 @@ class SettingsCreator(TrayPublishCreator):
# Fill 'version_to_use' if version control is enabled
if self.allow_version_control:
- asset_name = data["asset"]
+ if AYON_SERVER_ENABLED:
+ asset_name = data["folderPath"]
+ else:
+ asset_name = data["asset"]
subset_docs_by_asset_id = self._prepare_next_versions(
[asset_name], [subset_name])
version = subset_docs_by_asset_id[asset_name].get(subset_name)
@@ -162,10 +167,10 @@ class SettingsCreator(TrayPublishCreator):
asset_docs = get_assets(
self.project_name,
asset_names=asset_names,
- fields=["_id", "name"]
+ fields=["_id", "name", "data.parents"]
)
asset_names_by_id = {
- asset_doc["_id"]: asset_doc["name"]
+ asset_doc["_id"]: get_asset_name_identifier(asset_doc)
for asset_doc in asset_docs
}
subset_docs = list(get_subsets(
diff --git a/openpype/hosts/traypublisher/plugins/create/create_colorspace_look.py b/openpype/hosts/traypublisher/plugins/create/create_colorspace_look.py
index 5628d0973f..ac4c72a0ce 100644
--- a/openpype/hosts/traypublisher/plugins/create/create_colorspace_look.py
+++ b/openpype/hosts/traypublisher/plugins/create/create_colorspace_look.py
@@ -6,6 +6,7 @@ production type `ociolook`. All files are published as representation.
"""
from pathlib import Path
+from openpype import AYON_SERVER_ENABLED
from openpype.client import get_asset_by_name
from openpype.lib.attribute_definitions import (
FileDef, EnumDef, TextDef, UISeparatorDef
@@ -54,8 +55,12 @@ This creator publishes color space look file (LUT).
# this should never happen
raise CreatorError("Missing files from representation")
+ if AYON_SERVER_ENABLED:
+ asset_name = instance_data["folderPath"]
+ else:
+ asset_name = instance_data["asset"]
asset_doc = get_asset_by_name(
- self.project_name, instance_data["asset"])
+ self.project_name, asset_name)
subset_name = self.get_subset_name(
variant=instance_data["variant"],
diff --git a/openpype/hosts/traypublisher/plugins/create/create_editorial.py b/openpype/hosts/traypublisher/plugins/create/create_editorial.py
index a2746f115f..26cce35d55 100644
--- a/openpype/hosts/traypublisher/plugins/create/create_editorial.py
+++ b/openpype/hosts/traypublisher/plugins/create/create_editorial.py
@@ -1,6 +1,7 @@
import os
from copy import deepcopy
import opentimelineio as otio
+from openpype import AYON_SERVER_ENABLED
from openpype.client import (
get_asset_by_name,
get_project
@@ -101,14 +102,23 @@ class EditorialShotInstanceCreator(EditorialClipInstanceCreatorBase):
label = "Editorial Shot"
def get_instance_attr_defs(self):
- attr_defs = [
- TextDef(
- "asset_name",
- label="Asset name",
+ instance_attributes = []
+ if AYON_SERVER_ENABLED:
+ instance_attributes.append(
+ TextDef(
+ "folderPath",
+ label="Folder path"
+ )
)
- ]
- attr_defs.extend(CLIP_ATTR_DEFS)
- return attr_defs
+ else:
+ instance_attributes.append(
+ TextDef(
+ "shotName",
+ label="Shot name"
+ )
+ )
+ instance_attributes.extend(CLIP_ATTR_DEFS)
+ return instance_attributes
class EditorialPlateInstanceCreator(EditorialClipInstanceCreatorBase):
@@ -214,8 +224,11 @@ or updating already created. Publishing will create OTIO file.
i["family"] for i in self._creator_settings["family_presets"]
]
}
- # Create otio editorial instance
- asset_name = instance_data["asset"]
+ if AYON_SERVER_ENABLED:
+ asset_name = instance_data["folderPath"]
+ else:
+ asset_name = instance_data["asset"]
+
asset_doc = get_asset_by_name(self.project_name, asset_name)
if pre_create_data["fps"] == "from_selection":
@@ -595,19 +608,23 @@ or updating already created. Publishing will create OTIO file.
Returns:
str: label string
"""
- shot_name = instance_data["shotName"]
+ if AYON_SERVER_ENABLED:
+ asset_name = instance_data["creator_attributes"]["folderPath"]
+ else:
+ asset_name = instance_data["creator_attributes"]["shotName"]
+
variant_name = instance_data["variant"]
family = preset["family"]
- # get variant name from preset or from inharitance
+ # get variant name from preset or from inheritance
_variant_name = preset.get("variant") or variant_name
# subset name
subset_name = "{}{}".format(
family, _variant_name.capitalize()
)
- label = "{}_{}".format(
- shot_name,
+ label = "{} {}".format(
+ asset_name,
subset_name
)
@@ -666,7 +683,10 @@ or updating already created. Publishing will create OTIO file.
}
)
- self._validate_name_uniqueness(shot_name)
+ # It should be validated only in openpype since we are supporting
+ # publishing to AYON with folder path and uniqueness is not an issue
+ if not AYON_SERVER_ENABLED:
+ self._validate_name_uniqueness(shot_name)
timing_data = self._get_timing_data(
otio_clip,
@@ -677,35 +697,43 @@ or updating already created. Publishing will create OTIO file.
# create creator attributes
creator_attributes = {
- "asset_name": shot_name,
- "Parent hierarchy path": shot_metadata["hierarchy"],
+
"workfile_start_frame": workfile_start_frame,
"fps": fps,
"handle_start": int(handle_start),
"handle_end": int(handle_end)
}
+ # add timing data
creator_attributes.update(timing_data)
- # create shared new instance data
+ # create base instance data
base_instance_data = {
"shotName": shot_name,
"variant": variant_name,
-
- # HACK: just for temporal bug workaround
- # TODO: should loockup shot name for update
- "asset": parent_asset_name,
"task": "",
-
"newAssetPublishing": True,
-
- # parent time properties
"trackStartFrame": track_start_frame,
"timelineOffset": timeline_offset,
- "isEditorial": True,
# creator_attributes
"creator_attributes": creator_attributes
}
+ # update base instance data with context data
+ # and also update creator attributes with context data
+ if AYON_SERVER_ENABLED:
+ # TODO: this is here just to be able to publish
+ # to AYON with folder path
+ creator_attributes["folderPath"] = shot_metadata.pop("folderPath")
+ base_instance_data["folderPath"] = parent_asset_name
+ else:
+ creator_attributes.update({
+ "shotName": shot_name,
+ "Parent hierarchy path": shot_metadata["hierarchy"]
+ })
+
+ base_instance_data["asset"] = parent_asset_name
+ # add creator attributes to shared instance data
+ base_instance_data["creator_attributes"] = creator_attributes
# add hierarchy shot metadata
base_instance_data.update(shot_metadata)
diff --git a/openpype/hosts/traypublisher/plugins/create/create_movie_batch.py b/openpype/hosts/traypublisher/plugins/create/create_movie_batch.py
index 3454b6e135..8fa65c7fff 100644
--- a/openpype/hosts/traypublisher/plugins/create/create_movie_batch.py
+++ b/openpype/hosts/traypublisher/plugins/create/create_movie_batch.py
@@ -2,6 +2,8 @@ import copy
import os
import re
+from openpype import AYON_SERVER_ENABLED
+from openpype.client import get_asset_name_identifier
from openpype.lib import (
FileDef,
BoolDef,
@@ -64,8 +66,13 @@ class BatchMovieCreator(TrayPublishCreator):
subset_name, task_name = self._get_subset_and_task(
asset_doc, data["variant"], self.project_name)
+ asset_name = get_asset_name_identifier(asset_doc)
+
instance_data["task"] = task_name
- instance_data["asset"] = asset_doc["name"]
+ if AYON_SERVER_ENABLED:
+ instance_data["folderPath"] = asset_name
+ else:
+ instance_data["asset"] = asset_name
# Create new instance
new_instance = CreatedInstance(self.family, subset_name,
diff --git a/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py b/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py
index 92cedf6b5b..5e60a94927 100644
--- a/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py
+++ b/openpype/hosts/traypublisher/plugins/publish/collect_sequence_frame_data.py
@@ -28,9 +28,9 @@ class CollectSequenceFrameData(
return
# editorial would fail since they might not be in database yet
- is_editorial = instance.data.get("isEditorial")
- if is_editorial:
- self.log.debug("Instance is Editorial. Skipping.")
+ new_asset_publishing = instance.data.get("newAssetPublishing")
+ if new_asset_publishing:
+ self.log.debug("Instance is creating new asset. Skipping.")
return
frame_data = self.get_frame_data_from_repre_sequence(instance)
diff --git a/openpype/hosts/traypublisher/plugins/publish/collect_shot_instances.py b/openpype/hosts/traypublisher/plugins/publish/collect_shot_instances.py
index 78c1f14e4e..e00ac64244 100644
--- a/openpype/hosts/traypublisher/plugins/publish/collect_shot_instances.py
+++ b/openpype/hosts/traypublisher/plugins/publish/collect_shot_instances.py
@@ -2,6 +2,8 @@ from pprint import pformat
import pyblish.api
import opentimelineio as otio
+from openpype import AYON_SERVER_ENABLED
+
class CollectShotInstance(pyblish.api.InstancePlugin):
""" Collect shot instances
@@ -119,8 +121,7 @@ class CollectShotInstance(pyblish.api.InstancePlugin):
frame_end = _cr_attrs["frameEnd"]
frame_dur = frame_end - frame_start
- return {
- "asset": _cr_attrs["asset_name"],
+ data = {
"fps": float(_cr_attrs["fps"]),
"handleStart": _cr_attrs["handle_start"],
"handleEnd": _cr_attrs["handle_end"],
@@ -133,6 +134,12 @@ class CollectShotInstance(pyblish.api.InstancePlugin):
"sourceOut": _cr_attrs["sourceOut"],
"workfileFrameStart": workfile_start_frame
}
+ if AYON_SERVER_ENABLED:
+ data["asset"] = _cr_attrs["folderPath"]
+ else:
+ data["asset"] = _cr_attrs["shotName"]
+
+ return data
def _solve_hierarchy_context(self, instance):
""" Adding hierarchy data to context shared data.
@@ -148,7 +155,7 @@ class CollectShotInstance(pyblish.api.InstancePlugin):
else {}
)
- name = instance.data["asset"]
+ asset_name = instance.data["asset"]
# get handles
handle_start = int(instance.data["handleStart"])
@@ -170,7 +177,7 @@ class CollectShotInstance(pyblish.api.InstancePlugin):
parents = instance.data.get('parents', [])
- actual = {name: in_info}
+ actual = {asset_name: in_info}
for parent in reversed(parents):
parent_name = parent["entity_name"]
diff --git a/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py b/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py
index 4977a13374..95894848a4 100644
--- a/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py
+++ b/openpype/hosts/traypublisher/plugins/publish/validate_frame_ranges.py
@@ -31,9 +31,9 @@ class ValidateFrameRange(OptionalPyblishPluginMixin,
return
# editorial would fail since they might not be in database yet
- is_editorial = instance.data.get("isEditorial")
- if is_editorial:
- self.log.debug("Instance is Editorial. Skipping.")
+ new_asset_publishing = instance.data.get("newAssetPublishing")
+ if new_asset_publishing:
+ self.log.debug("Instance is creating new asset. Skipping.")
return
if (self.skip_timelines_check and
diff --git a/openpype/hosts/tvpaint/plugins/create/create_render.py b/openpype/hosts/tvpaint/plugins/create/create_render.py
index b7a7c208d9..667103432e 100644
--- a/openpype/hosts/tvpaint/plugins/create/create_render.py
+++ b/openpype/hosts/tvpaint/plugins/create/create_render.py
@@ -37,7 +37,8 @@ Todos:
import collections
from typing import Any, Optional, Union
-from openpype.client import get_asset_by_name
+from openpype import AYON_SERVER_ENABLED
+from openpype.client import get_asset_by_name, get_asset_name_identifier
from openpype.lib import (
prepare_template_data,
AbstractAttrDef,
@@ -784,18 +785,25 @@ class TVPaintAutoDetectRenderCreator(TVPaintCreator):
project_name,
host_name=self.create_context.host_name,
)
+ asset_name = get_asset_name_identifier(asset_doc)
if existing_instance is not None:
- existing_instance["asset"] = asset_doc["name"]
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
return existing_instance
instance_data: dict[str, str] = {
- "asset": asset_doc["name"],
"task": task_name,
"family": creator.family,
"variant": variant
}
+ if AYON_SERVER_ENABLED:
+ instance_data["folderPath"] = asset_name
+ else:
+ instance_data["asset"] = asset_name
pre_create_data: dict[str, str] = {
"group_id": group_id,
"mark_for_review": mark_for_review
@@ -820,6 +828,8 @@ class TVPaintAutoDetectRenderCreator(TVPaintCreator):
for layer_name in render_pass["layer_names"]:
render_pass_by_layer_name[layer_name] = render_pass
+ asset_name = get_asset_name_identifier(asset_doc)
+
for layer in layers:
layer_name = layer["name"]
variant = layer_name
@@ -838,17 +848,25 @@ class TVPaintAutoDetectRenderCreator(TVPaintCreator):
)
if render_pass is not None:
- render_pass["asset"] = asset_doc["name"]
+ if AYON_SERVER_ENABLED:
+ render_pass["folderPath"] = asset_name
+ else:
+ render_pass["asset"] = asset_name
+
render_pass["task"] = task_name
render_pass["subset"] = subset_name
continue
instance_data: dict[str, str] = {
- "asset": asset_doc["name"],
"task": task_name,
"family": creator.family,
"variant": variant
}
+ if AYON_SERVER_ENABLED:
+ instance_data["folderPath"] = asset_name
+ else:
+ instance_data["asset"] = asset_name
+
pre_create_data: dict[str, Any] = {
"render_layer_instance_id": render_layer_instance.id,
"layer_names": [layer_name],
@@ -882,9 +900,13 @@ class TVPaintAutoDetectRenderCreator(TVPaintCreator):
def create(self, subset_name, instance_data, pre_create_data):
project_name: str = self.create_context.get_current_project_name()
- asset_name: str = instance_data["asset"]
+ if AYON_SERVER_ENABLED:
+ asset_name: str = instance_data["folderPath"]
+ else:
+ asset_name: str = instance_data["asset"]
task_name: str = instance_data["task"]
- asset_doc: dict[str, Any] = get_asset_by_name(project_name, asset_name)
+ asset_doc: dict[str, Any] = get_asset_by_name(
+ project_name, asset_name)
render_layers_by_group_id: dict[int, CreatedInstance] = {}
render_passes_by_render_layer_id: dict[int, list[CreatedInstance]] = (
@@ -1061,7 +1083,6 @@ class TVPaintSceneRenderCreator(TVPaintAutoCreator):
host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": self.default_variant,
"creator_attributes": {
@@ -1073,6 +1094,10 @@ class TVPaintSceneRenderCreator(TVPaintAutoCreator):
self.default_pass_name
)
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
if not self.active_on_create:
data["active"] = False
@@ -1101,8 +1126,14 @@ class TVPaintSceneRenderCreator(TVPaintAutoCreator):
asset_name = create_context.get_current_asset_name()
task_name = create_context.get_current_task_name()
+ existing_name = None
+ if AYON_SERVER_ENABLED:
+ existing_name = existing_instance.get("folderPath")
+ if existing_name is None:
+ existing_name = existing_instance["asset"]
+
if (
- existing_instance["asset"] != asset_name
+ existing_name != asset_name
or existing_instance["task"] != task_name
):
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -1114,7 +1145,10 @@ class TVPaintSceneRenderCreator(TVPaintAutoCreator):
host_name,
existing_instance
)
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/tvpaint/plugins/create/create_review.py b/openpype/hosts/tvpaint/plugins/create/create_review.py
index 7bb7510a8e..5caf20f27d 100644
--- a/openpype/hosts/tvpaint/plugins/create/create_review.py
+++ b/openpype/hosts/tvpaint/plugins/create/create_review.py
@@ -1,3 +1,4 @@
+from openpype import AYON_SERVER_ENABLED
from openpype.client import get_asset_by_name
from openpype.pipeline import CreatedInstance
from openpype.hosts.tvpaint.api.plugin import TVPaintAutoCreator
@@ -33,6 +34,13 @@ class TVPaintReviewCreator(TVPaintAutoCreator):
asset_name = create_context.get_current_asset_name()
task_name = create_context.get_current_task_name()
+ if existing_instance is None:
+ existing_asset_name = None
+ elif AYON_SERVER_ENABLED:
+ existing_asset_name = existing_instance["folderPath"]
+ else:
+ existing_asset_name = existing_instance["asset"]
+
if existing_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
@@ -43,10 +51,14 @@ class TVPaintReviewCreator(TVPaintAutoCreator):
host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": self.default_variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
+
if not self.active_on_create:
data["active"] = False
@@ -59,7 +71,7 @@ class TVPaintReviewCreator(TVPaintAutoCreator):
self._add_instance_to_context(new_instance)
elif (
- existing_instance["asset"] != asset_name
+ existing_asset_name != asset_name
or existing_instance["task"] != task_name
):
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -71,6 +83,9 @@ class TVPaintReviewCreator(TVPaintAutoCreator):
host_name,
existing_instance
)
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/tvpaint/plugins/create/create_workfile.py b/openpype/hosts/tvpaint/plugins/create/create_workfile.py
index c3982c0eca..4ce5d7fc96 100644
--- a/openpype/hosts/tvpaint/plugins/create/create_workfile.py
+++ b/openpype/hosts/tvpaint/plugins/create/create_workfile.py
@@ -1,3 +1,4 @@
+from openpype import AYON_SERVER_ENABLED
from openpype.client import get_asset_by_name
from openpype.pipeline import CreatedInstance
from openpype.hosts.tvpaint.api.plugin import TVPaintAutoCreator
@@ -29,6 +30,13 @@ class TVPaintWorkfileCreator(TVPaintAutoCreator):
asset_name = create_context.get_current_asset_name()
task_name = create_context.get_current_task_name()
+ if existing_instance is None:
+ existing_asset_name = None
+ elif AYON_SERVER_ENABLED:
+ existing_asset_name = existing_instance["folderPath"]
+ else:
+ existing_asset_name = existing_instance["asset"]
+
if existing_instance is None:
asset_doc = get_asset_by_name(project_name, asset_name)
subset_name = self.get_subset_name(
@@ -39,10 +47,13 @@ class TVPaintWorkfileCreator(TVPaintAutoCreator):
host_name
)
data = {
- "asset": asset_name,
"task": task_name,
"variant": self.default_variant
}
+ if AYON_SERVER_ENABLED:
+ data["folderPath"] = asset_name
+ else:
+ data["asset"] = asset_name
new_instance = CreatedInstance(
self.family, subset_name, data, self
@@ -53,7 +64,7 @@ class TVPaintWorkfileCreator(TVPaintAutoCreator):
self._add_instance_to_context(new_instance)
elif (
- existing_instance["asset"] != asset_name
+ existing_asset_name != asset_name
or existing_instance["task"] != task_name
):
asset_doc = get_asset_by_name(project_name, asset_name)
@@ -65,6 +76,9 @@ class TVPaintWorkfileCreator(TVPaintAutoCreator):
host_name,
existing_instance
)
- existing_instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ existing_instance["folderPath"] = asset_name
+ else:
+ existing_instance["asset"] = asset_name
existing_instance["task"] = task_name
existing_instance["subset"] = subset_name
diff --git a/openpype/hosts/tvpaint/plugins/publish/validate_asset_name.py b/openpype/hosts/tvpaint/plugins/publish/validate_asset_name.py
index 9347960d3f..dc29e6c278 100644
--- a/openpype/hosts/tvpaint/plugins/publish/validate_asset_name.py
+++ b/openpype/hosts/tvpaint/plugins/publish/validate_asset_name.py
@@ -1,4 +1,5 @@
import pyblish.api
+from openpype import AYON_SERVER_ENABLED
from openpype.pipeline import (
PublishXmlValidationError,
OptionalPyblishPluginMixin,
@@ -24,12 +25,19 @@ class FixAssetNames(pyblish.api.Action):
old_instance_items = list_instances()
new_instance_items = []
for instance_item in old_instance_items:
- instance_asset_name = instance_item.get("asset")
+ if AYON_SERVER_ENABLED:
+ instance_asset_name = instance_item.get("folderPath")
+ else:
+ instance_asset_name = instance_item.get("asset")
+
if (
instance_asset_name
and instance_asset_name != context_asset_name
):
- instance_item["asset"] = context_asset_name
+ if AYON_SERVER_ENABLED:
+ instance_item["folderPath"] = context_asset_name
+ else:
+ instance_item["asset"] = context_asset_name
new_instance_items.append(instance_item)
write_instances(new_instance_items)
diff --git a/openpype/lib/applications.py b/openpype/lib/applications.py
index ff5e27c122..4d75a01e1d 100644
--- a/openpype/lib/applications.py
+++ b/openpype/lib/applications.py
@@ -12,6 +12,7 @@ from abc import ABCMeta, abstractmethod
import six
from openpype import AYON_SERVER_ENABLED, PACKAGE_DIR
+from openpype.client import get_asset_name_identifier
from openpype.settings import (
get_system_settings,
get_project_settings,
@@ -1728,7 +1729,9 @@ def prepare_context_environments(data, env_group=None, modules_manager=None):
"AVALON_APP_NAME": app.full_name
}
if asset_doc:
- context_env["AVALON_ASSET"] = asset_doc["name"]
+ asset_name = get_asset_name_identifier(asset_doc)
+ context_env["AVALON_ASSET"] = asset_name
+
if task_name:
context_env["AVALON_TASK"] = task_name
diff --git a/openpype/modules/__init__.py b/openpype/modules/__init__.py
index 1f345feea9..3097805353 100644
--- a/openpype/modules/__init__.py
+++ b/openpype/modules/__init__.py
@@ -10,6 +10,7 @@ from .interfaces import (
)
from .base import (
+ AYONAddon,
OpenPypeModule,
OpenPypeAddOn,
@@ -35,6 +36,7 @@ __all__ = (
"ISettingsChangeListener",
"IHostAddon",
+ "AYONAddon",
"OpenPypeModule",
"OpenPypeAddOn",
diff --git a/openpype/modules/base.py b/openpype/modules/base.py
index 4636906cec..1a2513b4b4 100644
--- a/openpype/modules/base.py
+++ b/openpype/modules/base.py
@@ -1,5 +1,5 @@
# -*- coding: utf-8 -*-
-"""Base class for Pype Modules."""
+"""Base class for AYON addons."""
import copy
import os
import sys
@@ -11,6 +11,7 @@ import platform
import threading
import collections
import traceback
+
from uuid import uuid4
from abc import ABCMeta, abstractmethod
@@ -29,9 +30,12 @@ from openpype.settings import (
from openpype.settings.lib import (
get_studio_system_settings_overrides,
- load_json_file
+ load_json_file,
+)
+from openpype.settings.ayon_settings import (
+ is_dev_mode_enabled,
+ get_ayon_settings,
)
-from openpype.settings.ayon_settings import is_dev_mode_enabled
from openpype.lib import (
Logger,
@@ -47,11 +51,11 @@ from .interfaces import (
ITrayService
)
-# Files that will be always ignored on modules import
+# Files that will be always ignored on addons import
IGNORED_FILENAMES = (
"__pycache__",
)
-# Files ignored on modules import from "./openpype/modules"
+# Files ignored on addons import from "./openpype/modules"
IGNORED_DEFAULT_FILENAMES = (
"__init__.py",
"base.py",
@@ -59,8 +63,8 @@ IGNORED_DEFAULT_FILENAMES = (
"example_addons",
"default_modules",
)
-# Modules that won't be loaded in AYON mode from "./openpype/modules"
-# - the same modules are ignored in "./server_addon/create_ayon_addons.py"
+# Addons that won't be loaded in AYON mode from "./openpype/modules"
+# - the same addons are ignored in "./server_addon/create_ayon_addons.py"
IGNORED_FILENAMES_IN_AYON = {
"ftrack",
"shotgrid",
@@ -68,6 +72,10 @@ IGNORED_FILENAMES_IN_AYON = {
"slack",
"kitsu",
}
+IGNORED_HOSTS_IN_AYON = {
+ "flame",
+ "harmony",
+}
# Inherit from `object` for Python 2 hosts
@@ -466,7 +474,7 @@ def _load_ayon_addons(openpype_modules, modules_key, log):
attr = getattr(mod, attr_name)
if (
inspect.isclass(attr)
- and issubclass(attr, OpenPypeModule)
+ and issubclass(attr, AYONAddon)
):
imported_modules.append(mod)
break
@@ -536,6 +544,11 @@ def _load_modules():
addons_dir = os.path.join(os.path.dirname(current_dir), "addons")
module_dirs.append(addons_dir)
+ ignored_host_names = set(IGNORED_HOSTS_IN_AYON)
+ ignored_current_dir_filenames = set(IGNORED_DEFAULT_FILENAMES)
+ if AYON_SERVER_ENABLED:
+ ignored_current_dir_filenames |= IGNORED_FILENAMES_IN_AYON
+
processed_paths = set()
for dirpath in frozenset(module_dirs):
# Skip already processed paths
@@ -551,9 +564,6 @@ def _load_modules():
is_in_current_dir = dirpath == current_dir
is_in_host_dir = dirpath == hosts_dir
- ignored_current_dir_filenames = set(IGNORED_DEFAULT_FILENAMES)
- if AYON_SERVER_ENABLED:
- ignored_current_dir_filenames |= IGNORED_FILENAMES_IN_AYON
for filename in os.listdir(dirpath):
# Ignore filenames
@@ -566,6 +576,12 @@ def _load_modules():
):
continue
+ if (
+ is_in_host_dir
+ and filename in ignored_host_names
+ ):
+ continue
+
fullpath = os.path.join(dirpath, filename)
basename, ext = os.path.splitext(filename)
@@ -633,26 +649,22 @@ def _load_modules():
@six.add_metaclass(ABCMeta)
-class OpenPypeModule:
- """Base class of pype module.
+class AYONAddon(object):
+ """Base class of AYON addon.
Attributes:
- id (UUID): Module's id.
- enabled (bool): Is module enabled.
- name (str): Module name.
- manager (ModulesManager): Manager that created the module.
+ id (UUID): Addon object id.
+ enabled (bool): Is addon enabled.
+ name (str): Addon name.
+
+ Args:
+ manager (ModulesManager): Manager object who discovered addon.
+ settings (dict[str, Any]): AYON settings.
"""
- # Disable by default
- enabled = False
+ enabled = True
_id = None
- @property
- @abstractmethod
- def name(self):
- """Module's name."""
- pass
-
def __init__(self, manager, settings):
self.manager = manager
@@ -662,22 +674,45 @@ class OpenPypeModule:
@property
def id(self):
+ """Random id of addon object.
+
+ Returns:
+ str: Object id.
+ """
+
if self._id is None:
self._id = uuid4()
return self._id
+ @property
@abstractmethod
- def initialize(self, module_settings):
- """Initialization of module attributes.
+ def name(self):
+ """Addon name.
- It is not recommended to override __init__ that's why specific method
- was implemented.
+ Returns:
+ str: Addon name.
"""
pass
- def connect_with_modules(self, enabled_modules):
- """Connect with other enabled modules."""
+ def initialize(self, settings):
+ """Initialization of module attributes.
+
+ It is not recommended to override __init__ that's why specific method
+ was implemented.
+
+ Args:
+ settings (dict[str, Any]): Settings.
+ """
+
+ pass
+
+ def connect_with_modules(self, enabled_addons):
+ """Connect with other enabled addons.
+
+ Args:
+ enabled_addons (list[AYONAddon]): Addons that are enabled.
+ """
pass
@@ -685,6 +720,9 @@ class OpenPypeModule:
"""Get global environments values of module.
Environment variables that can be get only from system settings.
+
+ Returns:
+ dict[str, str]: Environment variables.
"""
return {}
@@ -697,7 +735,7 @@ class OpenPypeModule:
Args:
application (Application): Application that is launched.
- env (dict): Current environment variables.
+ env (dict[str, str]): Current environment variables.
"""
pass
@@ -713,7 +751,8 @@ class OpenPypeModule:
to receive from 'host' object.
Args:
- host (ModuleType): Access to installed/registered host object.
+ host (Union[ModuleType, HostBase]): Access to installed/registered
+ host object.
host_name (str): Name of host.
project_name (str): Project name which is main part of host
context.
@@ -727,47 +766,66 @@ class OpenPypeModule:
The best practise is to create click group for whole module which is
used to separate commands.
- class MyPlugin(OpenPypeModule):
- ...
- def cli(self, module_click_group):
- module_click_group.add_command(cli_main)
+ Example:
+ class MyPlugin(AYONAddon):
+ ...
+ def cli(self, module_click_group):
+ module_click_group.add_command(cli_main)
- @click.group(, help="")
- def cli_main():
- pass
+ @click.group(, help="")
+ def cli_main():
+ pass
- @cli_main.command()
- def mycommand():
- print("my_command")
+ @cli_main.command()
+ def mycommand():
+ print("my_command")
+
+ Args:
+ module_click_group (click.Group): Group to which can be added
+ commands.
"""
pass
+class OpenPypeModule(AYONAddon):
+ """Base class of OpenPype module.
+
+ Instead of 'AYONAddon' are passed in module settings.
+
+ Args:
+ manager (ModulesManager): Manager object who discovered addon.
+ settings (dict[str, Any]): OpenPype settings.
+ """
+
+ # Disable by default
+ enabled = False
+
+
class OpenPypeAddOn(OpenPypeModule):
# Enable Addon by default
enabled = True
- def initialize(self, module_settings):
- """Initialization is not be required for most of addons."""
- pass
-
class ModulesManager:
"""Manager of Pype modules helps to load and prepare them to work.
Args:
- modules_settings(dict): To be able create module manager with specified
- data. For settings changes callbacks and testing purposes.
+ system_settings (Optional[dict[str, Any]]): OpenPype system settings.
+ ayon_settings (Optional[dict[str, Any]]): AYON studio settings.
"""
+
# Helper attributes for report
_report_total_key = "Total"
+ _system_settings = None
+ _ayon_settings = None
- def __init__(self, _system_settings=None):
+ def __init__(self, system_settings=None, ayon_settings=None):
self.log = logging.getLogger(self.__class__.__name__)
- self._system_settings = _system_settings
+ self._system_settings = system_settings
+ self._ayon_settings = ayon_settings
self.modules = []
self.modules_by_id = {}
@@ -789,8 +847,9 @@ class ModulesManager:
default (Any): Default output if module is not available.
Returns:
- Union[OpenPypeModule, None]: Module found by name or None.
+ Union[AYONAddon, None]: Module found by name or None.
"""
+
return self.modules_by_name.get(module_name, default)
def get_enabled_module(self, module_name, default=None):
@@ -804,7 +863,7 @@ class ModulesManager:
not enabled.
Returns:
- Union[OpenPypeModule, None]: Enabled module found by name or None.
+ Union[AYONAddon, None]: Enabled module found by name or None.
"""
module = self.get(module_name)
@@ -819,11 +878,20 @@ class ModulesManager:
import openpype_modules
- self.log.debug("*** Pype modules initialization.")
+ self.log.debug("*** {} initialization.".format(
+ "AYON addons"
+ if AYON_SERVER_ENABLED
+ else "OpenPype modules"
+ ))
# Prepare settings for modules
- system_settings = getattr(self, "_system_settings", None)
+ system_settings = self._system_settings
if system_settings is None:
system_settings = get_system_settings()
+
+ ayon_settings = self._ayon_settings
+ if AYON_SERVER_ENABLED and ayon_settings is None:
+ ayon_settings = get_ayon_settings()
+
modules_settings = system_settings["modules"]
report = {}
@@ -836,12 +904,13 @@ class ModulesManager:
for name in dir(module):
modules_item = getattr(module, name, None)
# Filter globals that are not classes which inherit from
- # OpenPypeModule
+ # AYONAddon
if (
not inspect.isclass(modules_item)
+ or modules_item is AYONAddon
or modules_item is OpenPypeModule
or modules_item is OpenPypeAddOn
- or not issubclass(modules_item, OpenPypeModule)
+ or not issubclass(modules_item, AYONAddon)
):
continue
@@ -866,10 +935,14 @@ class ModulesManager:
module_classes.append(modules_item)
for modules_item in module_classes:
+ is_openpype_module = issubclass(modules_item, OpenPypeModule)
+ settings = (
+ modules_settings if is_openpype_module else ayon_settings
+ )
+ name = modules_item.__name__
try:
- name = modules_item.__name__
# Try initialize module
- module = modules_item(self, modules_settings)
+ module = modules_item(self, settings)
# Store initialized object
self.modules.append(module)
self.modules_by_id[module.id] = module
@@ -924,8 +997,9 @@ class ModulesManager:
"""Enabled modules initialized by the manager.
Returns:
- list: Initialized and enabled modules.
+ list[AYONAddon]: Initialized and enabled modules.
"""
+
return [
module
for module in self.modules
@@ -1108,7 +1182,7 @@ class ModulesManager:
host_name (str): Host name for which is found host module.
Returns:
- OpenPypeModule: Found host module by name.
+ AYONAddon: Found host module by name.
None: There was not found module inheriting IHostAddon which has
host name set to passed 'host_name'.
"""
@@ -1129,12 +1203,11 @@ class ModulesManager:
inheriting 'IHostAddon'.
"""
- host_names = {
+ return {
module.host_name
for module in self.get_enabled_modules()
if isinstance(module, IHostAddon)
}
- return host_names
def print_report(self):
"""Print out report of time spent on modules initialization parts.
@@ -1290,6 +1363,10 @@ class TrayModulesManager(ModulesManager):
callback can be defined with `doubleclick_callback` attribute.
Missing feature how to define default callback.
+
+ Args:
+ addon (AYONAddon): Addon object.
+ callback (FunctionType): Function callback.
"""
callback_name = "_".join([module.name, callback.__name__])
if callback_name not in self.doubleclick_callbacks:
@@ -1310,11 +1387,17 @@ class TrayModulesManager(ModulesManager):
self.tray_menu(tray_menu)
def get_enabled_tray_modules(self):
- output = []
- for module in self.modules:
- if module.enabled and isinstance(module, ITrayModule):
- output.append(module)
- return output
+ """Enabled tray modules.
+
+ Returns:
+ list[AYONAddon]: Enabled addons that inherit from tray interface.
+ """
+
+ return [
+ module
+ for module in self.modules
+ if module.enabled and isinstance(module, ITrayModule)
+ ]
def restart_tray(self):
if self.tray_manager:
diff --git a/openpype/modules/deadline/plugins/publish/submit_publish_job.py b/openpype/modules/deadline/plugins/publish/submit_publish_job.py
index 6ed5819f2b..c9019b496b 100644
--- a/openpype/modules/deadline/plugins/publish/submit_publish_job.py
+++ b/openpype/modules/deadline/plugins/publish/submit_publish_job.py
@@ -708,6 +708,7 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
"""
project_name = context.data["projectName"]
+ host_name = context.data["hostName"]
if not version:
version = get_last_version_by_subset_name(
project_name,
@@ -719,7 +720,7 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin,
else:
version = get_versioning_start(
project_name,
- template_data["app"],
+ host_name,
task_name=template_data["task"]["name"],
task_type=template_data["task"]["type"],
family="render",
diff --git a/openpype/modules/royalrender/plugins/publish/create_publish_royalrender_job.py b/openpype/modules/royalrender/plugins/publish/create_publish_royalrender_job.py
index 3eb49a39ee..e13bf97e54 100644
--- a/openpype/modules/royalrender/plugins/publish/create_publish_royalrender_job.py
+++ b/openpype/modules/royalrender/plugins/publish/create_publish_royalrender_job.py
@@ -189,7 +189,7 @@ class CreatePublishRoyalRenderJob(pyblish.api.InstancePlugin,
environment = RREnvList({
"AVALON_PROJECT": anatomy_data["project"]["name"],
- "AVALON_ASSET": anatomy_data["asset"],
+ "AVALON_ASSET": instance.context.data["asset"],
"AVALON_TASK": anatomy_data["task"]["name"],
"OPENPYPE_USERNAME": anatomy_data["user"]
})
diff --git a/openpype/modules/slack/plugins/publish/collect_slack_family.py b/openpype/modules/slack/plugins/publish/collect_slack_family.py
index b3e7bbdcec..cbed2d1012 100644
--- a/openpype/modules/slack/plugins/publish/collect_slack_family.py
+++ b/openpype/modules/slack/plugins/publish/collect_slack_family.py
@@ -38,7 +38,7 @@ class CollectSlackFamilies(pyblish.api.InstancePlugin,
"families": family,
"tasks": task_data.get("name"),
"task_types": task_data.get("type"),
- "hosts": instance.data["anatomyData"]["app"],
+ "hosts": instance.context.data["hostName"],
"subsets": instance.data["subset"]
}
profile = filter_profiles(self.profiles, key_values,
diff --git a/openpype/modules/timers_manager/timers_manager.py b/openpype/modules/timers_manager/timers_manager.py
index 43286f7da4..674d834a1d 100644
--- a/openpype/modules/timers_manager/timers_manager.py
+++ b/openpype/modules/timers_manager/timers_manager.py
@@ -247,7 +247,7 @@ class TimersManager(
return {
"project_name": project_name,
"asset_id": str(asset_doc["_id"]),
- "asset_name": asset_doc["name"],
+ "asset_name": asset_name,
"task_name": task_name,
"task_type": task_type,
"hierarchy": hierarchy_items
diff --git a/openpype/pipeline/context_tools.py b/openpype/pipeline/context_tools.py
index 034bbc0070..a607c90912 100644
--- a/openpype/pipeline/context_tools.py
+++ b/openpype/pipeline/context_tools.py
@@ -18,6 +18,7 @@ from openpype.client import (
get_asset_by_id,
get_asset_by_name,
version_is_latest,
+ get_asset_name_identifier,
get_ayon_server_api_connection,
)
from openpype.lib.events import emit_event
@@ -44,7 +45,7 @@ from . import (
_is_installed = False
_process_id = None
-_registered_root = {"_": ""}
+_registered_root = {"_": {}}
_registered_host = {"_": None}
# Keep modules manager (and it's modules) in memory
# - that gives option to register modules' callbacks
@@ -85,15 +86,22 @@ def register_root(path):
def registered_root():
- """Return currently registered root"""
- root = _registered_root["_"]
- if root:
- return root
+ """Return registered roots from current project anatomy.
- root = legacy_io.Session.get("AVALON_PROJECTS")
- if root:
- return os.path.normpath(root)
- return ""
+ Consider this does return roots only for current project and current
+ platforms, only if host was installer using 'install_host'.
+
+ Deprecated:
+ Please use project 'Anatomy' to get roots. This function is still used
+ at current core functions of load logic, but that will change
+ in future and this function will be removed eventually. Using this
+ function at new places can cause problems in the future.
+
+ Returns:
+ dict[str, str]: Root paths.
+ """
+
+ return _registered_root["_"]
def install_host(host):
@@ -592,14 +600,12 @@ def compute_session_changes(
Dict[str, str]: Changes in the Session dictionary.
"""
- changes = {}
-
# Get asset document and asset
if not asset_doc:
task_name = None
asset_name = None
else:
- asset_name = asset_doc["name"]
+ asset_name = get_asset_name_identifier(asset_doc)
# Detect any changes compared session
mapping = {
diff --git a/openpype/pipeline/create/context.py b/openpype/pipeline/create/context.py
index 25f03ddd3b..683699a0d1 100644
--- a/openpype/pipeline/create/context.py
+++ b/openpype/pipeline/create/context.py
@@ -11,7 +11,12 @@ from contextlib import contextmanager
import pyblish.logic
import pyblish.api
-from openpype.client import get_assets, get_asset_by_name
+from openpype import AYON_SERVER_ENABLED
+from openpype.client import (
+ get_assets,
+ get_asset_by_name,
+ get_asset_name_identifier,
+)
from openpype.settings import (
get_system_settings,
get_project_settings
@@ -922,9 +927,19 @@ class CreatedInstance:
self._orig_data = copy.deepcopy(data)
# Pop family and subset to prevent unexpected changes
+ # TODO change to 'productType' and 'productName' in AYON
data.pop("family", None)
data.pop("subset", None)
+ if AYON_SERVER_ENABLED:
+ asset_name = data.pop("asset", None)
+ if "folderPath" not in data:
+ data["folderPath"] = asset_name
+
+ elif "folderPath" in data:
+ asset_name = data.pop("folderPath").split("/")[-1]
+ if "asset" not in data:
+ data["asset"] = asset_name
# QUESTION Does it make sense to have data stored as ordered dict?
self._data = collections.OrderedDict()
@@ -1268,6 +1283,8 @@ class CreatedInstance:
def has_set_asset(self):
"""Asset name is set in data."""
+ if AYON_SERVER_ENABLED:
+ return "folderPath" in self._data
return "asset" in self._data
@property
@@ -2003,8 +2020,14 @@ class CreateContext:
project_name,
self.host_name
)
+ asset_name = get_asset_name_identifier(asset_doc)
+ if AYON_SERVER_ENABLED:
+ asset_name_key = "folderPath"
+ else:
+ asset_name_key = "asset"
+
instance_data = {
- "asset": asset_doc["name"],
+ asset_name_key: asset_name,
"task": task_name,
"family": creator.family,
"variant": variant
@@ -2229,34 +2252,51 @@ class CreateContext:
task_names_by_asset_name = {}
for instance in instances:
task_name = instance.get("task")
- asset_name = instance.get("asset")
+ if AYON_SERVER_ENABLED:
+ asset_name = instance.get("folderPath")
+ else:
+ asset_name = instance.get("asset")
if asset_name:
task_names_by_asset_name[asset_name] = set()
if task_name:
task_names_by_asset_name[asset_name].add(task_name)
- asset_names = [
+ asset_names = {
asset_name
for asset_name in task_names_by_asset_name.keys()
if asset_name is not None
- ]
+ }
+ fields = {"name", "data.tasks"}
+ if AYON_SERVER_ENABLED:
+ fields |= {"data.parents"}
asset_docs = list(get_assets(
self.project_name,
asset_names=asset_names,
- fields=["name", "data.tasks"]
+ fields=fields
))
task_names_by_asset_name = {}
+ asset_docs_by_name = collections.defaultdict(list)
for asset_doc in asset_docs:
- asset_name = asset_doc["name"]
+ asset_name = get_asset_name_identifier(asset_doc)
tasks = asset_doc.get("data", {}).get("tasks") or {}
task_names_by_asset_name[asset_name] = set(tasks.keys())
+ asset_docs_by_name[asset_doc["name"]].append(asset_doc)
for instance in instances:
if not instance.has_valid_asset or not instance.has_valid_task:
continue
- asset_name = instance["asset"]
+ if AYON_SERVER_ENABLED:
+ asset_name = instance["folderPath"]
+ if asset_name and "/" not in asset_name:
+ asset_docs = asset_docs_by_name.get(asset_name)
+ if len(asset_docs) == 1:
+ asset_name = get_asset_name_identifier(asset_docs[0])
+ instance["folderPath"] = asset_name
+ else:
+ asset_name = instance["asset"]
+
if asset_name not in task_names_by_asset_name:
instance.set_asset_invalid(True)
continue
diff --git a/openpype/pipeline/create/utils.py b/openpype/pipeline/create/utils.py
index 2ef1f02bd6..ce4af8f474 100644
--- a/openpype/pipeline/create/utils.py
+++ b/openpype/pipeline/create/utils.py
@@ -1,6 +1,11 @@
import collections
-from openpype.client import get_assets, get_subsets, get_last_versions
+from openpype.client import (
+ get_assets,
+ get_subsets,
+ get_last_versions,
+ get_asset_name_identifier,
+)
def get_last_versions_for_instances(
@@ -52,10 +57,10 @@ def get_last_versions_for_instances(
asset_docs = get_assets(
project_name,
asset_names=subset_names_by_asset_name.keys(),
- fields=["name", "_id"]
+ fields=["name", "_id", "data.parents"]
)
asset_names_by_id = {
- asset_doc["_id"]: asset_doc["name"]
+ asset_doc["_id"]: get_asset_name_identifier(asset_doc)
for asset_doc in asset_docs
}
if not asset_names_by_id:
diff --git a/openpype/pipeline/legacy_io.py b/openpype/pipeline/legacy_io.py
index 60fa035c22..864102dff9 100644
--- a/openpype/pipeline/legacy_io.py
+++ b/openpype/pipeline/legacy_io.py
@@ -30,7 +30,7 @@ def install():
session = session_data_from_environment(context_keys=True)
- session["schema"] = "openpype:session-3.0"
+ session["schema"] = "openpype:session-4.0"
try:
schema.validate(session)
except schema.ValidationError as e:
diff --git a/openpype/pipeline/mongodb.py b/openpype/pipeline/mongodb.py
index 41a44c7373..c948983c3d 100644
--- a/openpype/pipeline/mongodb.py
+++ b/openpype/pipeline/mongodb.py
@@ -62,8 +62,6 @@ def auto_reconnect(func):
SESSION_CONTEXT_KEYS = (
- # Root directory of projects on disk
- "AVALON_PROJECTS",
# Name of current Project
"AVALON_PROJECT",
# Name of current Asset
diff --git a/openpype/pipeline/schema/session-4.0.json b/openpype/pipeline/schema/session-4.0.json
new file mode 100644
index 0000000000..0dab48aa46
--- /dev/null
+++ b/openpype/pipeline/schema/session-4.0.json
@@ -0,0 +1,61 @@
+{
+ "$schema": "http://json-schema.org/draft-04/schema#",
+
+ "title": "openpype:session-4.0",
+ "description": "The Avalon environment",
+
+ "type": "object",
+
+ "additionalProperties": true,
+
+ "required": [
+ "AVALON_PROJECT"
+ ],
+
+ "properties": {
+ "AVALON_PROJECT": {
+ "description": "Name of project",
+ "type": "string",
+ "pattern": "^\\w*$",
+ "example": "Hulk"
+ },
+ "AVALON_ASSET": {
+ "description": "Name of asset",
+ "type": "string",
+ "pattern": "^[\\/\\w]*$",
+ "example": "Bruce"
+ },
+ "AVALON_TASK": {
+ "description": "Name of task",
+ "type": "string",
+ "pattern": "^\\w*$",
+ "example": "modeling"
+ },
+ "AVALON_APP": {
+ "description": "Name of host",
+ "type": "string",
+ "pattern": "^\\w*$",
+ "example": "maya"
+ },
+ "AVALON_DB": {
+ "description": "Name of database",
+ "type": "string",
+ "pattern": "^\\w*$",
+ "example": "avalon",
+ "default": "avalon"
+ },
+ "AVALON_LABEL": {
+ "description": "Nice name of Avalon, used in e.g. graphical user interfaces",
+ "type": "string",
+ "example": "MyLabel",
+ "default": "Avalon"
+ },
+ "AVALON_TIMEOUT": {
+ "description": "Wherever there is a need for a timeout, this is the default value.",
+ "type": "string",
+ "pattern": "^[0-9]*$",
+ "default": "1000",
+ "example": "1000"
+ }
+ }
+}
diff --git a/openpype/plugins/publish/collect_anatomy_instance_data.py b/openpype/plugins/publish/collect_anatomy_instance_data.py
index b4f4d6a16a..1b4b44e40e 100644
--- a/openpype/plugins/publish/collect_anatomy_instance_data.py
+++ b/openpype/plugins/publish/collect_anatomy_instance_data.py
@@ -30,7 +30,8 @@ import pyblish.api
from openpype.client import (
get_assets,
get_subsets,
- get_last_versions
+ get_last_versions,
+ get_asset_name_identifier,
)
from openpype.pipeline.version_start import get_versioning_start
@@ -60,6 +61,9 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
self.log.debug("Querying asset documents for instances.")
context_asset_doc = context.data.get("assetEntity")
+ context_asset_name = None
+ if context_asset_doc:
+ context_asset_name = get_asset_name_identifier(context_asset_doc)
instances_with_missing_asset_doc = collections.defaultdict(list)
for instance in context:
@@ -68,15 +72,15 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
# There is possibility that assetEntity on instance is already set
# which can happen in standalone publisher
- if (
- instance_asset_doc
- and instance_asset_doc["name"] == _asset_name
- ):
- continue
+ if instance_asset_doc:
+ instance_asset_name = get_asset_name_identifier(
+ instance_asset_doc)
+ if instance_asset_name == _asset_name:
+ continue
# Check if asset name is the same as what is in context
# - they may be different, e.g. in NukeStudio
- if context_asset_doc and context_asset_doc["name"] == _asset_name:
+ if context_asset_name and context_asset_name == _asset_name:
instance.data["assetEntity"] = context_asset_doc
else:
@@ -93,7 +97,7 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
asset_docs = get_assets(project_name, asset_names=asset_names)
asset_docs_by_name = {
- asset_doc["name"]: asset_doc
+ get_asset_name_identifier(asset_doc): asset_doc
for asset_doc in asset_docs
}
@@ -183,35 +187,29 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
self.log.debug("Storing anatomy data to instance data.")
project_doc = context.data["projectEntity"]
- context_asset_doc = context.data.get("assetEntity")
-
project_task_types = project_doc["config"]["tasks"]
for instance in context:
+ asset_doc = instance.data.get("assetEntity")
anatomy_updates = {
- "asset": instance.data["asset"],
- "folder": {
- "name": instance.data["asset"],
- },
"family": instance.data["family"],
"subset": instance.data["subset"],
}
-
- # Hierarchy
- asset_doc = instance.data.get("assetEntity")
- if (
- asset_doc
- and (
- not context_asset_doc
- or asset_doc["_id"] != context_asset_doc["_id"]
- )
- ):
+ if asset_doc:
parents = asset_doc["data"].get("parents") or list()
parent_name = project_doc["name"]
if parents:
parent_name = parents[-1]
- anatomy_updates["hierarchy"] = "/".join(parents)
- anatomy_updates["parent"] = parent_name
+
+ hierarchy = "/".join(parents)
+ anatomy_updates.update({
+ "asset": asset_doc["name"],
+ "hierarchy": hierarchy,
+ "parent": parent_name,
+ "folder": {
+ "name": asset_doc["name"],
+ },
+ })
# Task
task_type = None
diff --git a/openpype/plugins/publish/collect_audio.py b/openpype/plugins/publish/collect_audio.py
index 6aaadfc568..734a625852 100644
--- a/openpype/plugins/publish/collect_audio.py
+++ b/openpype/plugins/publish/collect_audio.py
@@ -6,6 +6,7 @@ from openpype.client import (
get_subsets,
get_last_versions,
get_representations,
+ get_asset_name_identifier,
)
from openpype.pipeline.load import get_representation_path_with_anatomy
@@ -121,12 +122,13 @@ class CollectAudio(pyblish.api.ContextPlugin):
asset_docs = get_assets(
project_name,
asset_names=asset_names,
- fields=["_id", "name"]
+ fields=["_id", "name", "data.parents"]
)
- asset_id_by_name = {}
- for asset_doc in asset_docs:
- asset_id_by_name[asset_doc["name"]] = asset_doc["_id"]
+ asset_id_by_name = {
+ get_asset_name_identifier(asset_doc): asset_doc["_id"]
+ for asset_doc in asset_docs
+ }
asset_ids = set(asset_id_by_name.values())
# Query subsets with name define by 'audio_subset_name' attr
diff --git a/openpype/plugins/publish/collect_comment.py b/openpype/plugins/publish/collect_comment.py
index 9f41e37f22..38d61a7071 100644
--- a/openpype/plugins/publish/collect_comment.py
+++ b/openpype/plugins/publish/collect_comment.py
@@ -103,10 +103,10 @@ class CollectComment(
instance.data["comment"] = instance_comment
if instance_comment:
- msg_end = " has comment set to: \"{}\"".format(
+ msg_end = "has comment set to: \"{}\"".format(
instance_comment)
else:
- msg_end = " does not have set comment"
+ msg_end = "does not have set comment"
self.log.debug("Instance {} {}".format(instance_label, msg_end))
def cleanup_comment(self, comment):
diff --git a/openpype/plugins/publish/collect_from_create_context.py b/openpype/plugins/publish/collect_from_create_context.py
index 8806a13ca0..84f6141069 100644
--- a/openpype/plugins/publish/collect_from_create_context.py
+++ b/openpype/plugins/publish/collect_from_create_context.py
@@ -4,6 +4,7 @@
import os
import pyblish.api
+from openpype import AYON_SERVER_ENABLED
from openpype.host import IPublishHost
from openpype.pipeline import legacy_io, registered_host
from openpype.pipeline.create import CreateContext
@@ -38,6 +39,8 @@ class CollectFromCreateContext(pyblish.api.ContextPlugin):
for created_instance in create_context.instances:
instance_data = created_instance.data_to_store()
+ if AYON_SERVER_ENABLED:
+ instance_data["asset"] = instance_data.pop("folderPath")
if instance_data["active"]:
thumbnail_path = thumbnail_paths_by_instance_id.get(
created_instance.id
diff --git a/openpype/plugins/publish/collect_resources_path.py b/openpype/plugins/publish/collect_resources_path.py
index 14c13310df..a7f12bdfdb 100644
--- a/openpype/plugins/publish/collect_resources_path.py
+++ b/openpype/plugins/publish/collect_resources_path.py
@@ -69,9 +69,9 @@ class CollectResourcesPath(pyblish.api.InstancePlugin):
def process(self, instance):
# editorial would fail since they might not be in database yet
- is_editorial = instance.data.get("isEditorial")
- if is_editorial:
- self.log.debug("Instance is Editorial. Skipping.")
+ new_asset_publishing = instance.data.get("newAssetPublishing")
+ if new_asset_publishing:
+ self.log.debug("Instance is creating new asset. Skipping.")
return
anatomy = instance.context.data["anatomy"]
diff --git a/openpype/plugins/publish/extract_hierarchy_to_ayon.py b/openpype/plugins/publish/extract_hierarchy_to_ayon.py
index 0d9131718b..ef69369d67 100644
--- a/openpype/plugins/publish/extract_hierarchy_to_ayon.py
+++ b/openpype/plugins/publish/extract_hierarchy_to_ayon.py
@@ -8,7 +8,7 @@ from ayon_api import slugify_string
from ayon_api.entity_hub import EntityHub
from openpype import AYON_SERVER_ENABLED
-from openpype.client import get_assets
+from openpype.client import get_assets, get_asset_name_identifier
from openpype.pipeline.template_data import (
get_asset_template_data,
get_task_template_data,
@@ -58,7 +58,7 @@ class ExtractHierarchyToAYON(pyblish.api.ContextPlugin):
project_name, asset_names=instances_by_asset_name.keys()
)
asset_docs_by_name = {
- asset_doc["name"]: asset_doc
+ get_asset_name_identifier(asset_doc): asset_doc
for asset_doc in asset_docs
}
for asset_name, instances in instances_by_asset_name.items():
@@ -191,15 +191,15 @@ class ExtractHierarchyToAYON(pyblish.api.ContextPlugin):
"""
# filter only the active publishing instances
- active_folder_names = set()
+ active_folder_paths = set()
for instance in context:
if instance.data.get("publish") is not False:
- active_folder_names.add(instance.data.get("asset"))
+ active_folder_paths.add(instance.data.get("asset"))
- active_folder_names.discard(None)
+ active_folder_paths.discard(None)
- self.log.debug("Active folder names: {}".format(active_folder_names))
- if not active_folder_names:
+ self.log.debug("Active folder paths: {}".format(active_folder_paths))
+ if not active_folder_paths:
return None
project_item = None
@@ -230,12 +230,13 @@ class ExtractHierarchyToAYON(pyblish.api.ContextPlugin):
if not children_context:
continue
- for asset_name, asset_info in children_context.items():
+ for asset, asset_info in children_context.items():
if (
- asset_name not in active_folder_names
+ asset not in active_folder_paths
and not asset_info.get("childs")
):
continue
+ asset_name = asset.split("/")[-1]
item_id = uuid.uuid4().hex
new_item = copy.deepcopy(asset_info)
new_item["name"] = asset_name
@@ -252,7 +253,7 @@ class ExtractHierarchyToAYON(pyblish.api.ContextPlugin):
items_by_id[item_id] = new_item
parent_id_by_item_id[item_id] = parent_id
- if asset_name in active_folder_names:
+ if asset in active_folder_paths:
valid_ids.add(item_id)
hierarchy_queue.append((item_id, new_children_context))
diff --git a/openpype/plugins/publish/validate_editorial_asset_name.py b/openpype/plugins/publish/validate_editorial_asset_name.py
index fca0d8e7f5..b5afc49f2e 100644
--- a/openpype/plugins/publish/validate_editorial_asset_name.py
+++ b/openpype/plugins/publish/validate_editorial_asset_name.py
@@ -2,7 +2,7 @@ from pprint import pformat
import pyblish.api
-from openpype.client import get_assets
+from openpype.client import get_assets, get_asset_name_identifier
class ValidateEditorialAssetName(pyblish.api.ContextPlugin):
@@ -34,8 +34,11 @@ class ValidateEditorialAssetName(pyblish.api.ContextPlugin):
self.log.debug("__ db_assets: {}".format(db_assets))
asset_db_docs = {
- str(e["name"]): [str(p) for p in e["data"]["parents"]]
- for e in db_assets}
+ get_asset_name_identifier(asset_doc): list(
+ asset_doc["data"]["parents"]
+ )
+ for asset_doc in db_assets
+ }
self.log.debug("__ project_entities: {}".format(
pformat(asset_db_docs)))
diff --git a/openpype/settings/ayon_settings.py b/openpype/settings/ayon_settings.py
index 4664153786..6676e71a8e 100644
--- a/openpype/settings/ayon_settings.py
+++ b/openpype/settings/ayon_settings.py
@@ -651,6 +651,13 @@ def _convert_3dsmax_project_settings(ayon_settings, output):
attributes = {}
ayon_publish["ValidateAttributes"]["attributes"] = attributes
+ if "ValidateLoadedPlugin" in ayon_publish:
+ loaded_plugin = (
+ ayon_publish["ValidateLoadedPlugin"]["family_plugins_mapping"]
+ )
+ for item in loaded_plugin:
+ item["families"] = item.pop("product_types")
+
output["max"] = ayon_max
@@ -933,6 +940,23 @@ def _convert_photoshop_project_settings(ayon_settings, output):
output["photoshop"] = ayon_photoshop
+def _convert_substancepainter_project_settings(ayon_settings, output):
+ if "substancepainter" not in ayon_settings:
+ return
+
+ ayon_substance_painter = ayon_settings["substancepainter"]
+ _convert_host_imageio(ayon_substance_painter)
+ if "shelves" in ayon_substance_painter:
+ shelves_items = ayon_substance_painter["shelves"]
+ new_shelves_items = {
+ item["name"]: item["value"]
+ for item in shelves_items
+ }
+ ayon_substance_painter["shelves"] = new_shelves_items
+
+ output["substancepainter"] = ayon_substance_painter
+
+
def _convert_tvpaint_project_settings(ayon_settings, output):
if "tvpaint" not in ayon_settings:
return
@@ -1391,6 +1415,7 @@ def convert_project_settings(ayon_settings, default_settings):
_convert_nuke_project_settings(ayon_settings, output)
_convert_hiero_project_settings(ayon_settings, output)
_convert_photoshop_project_settings(ayon_settings, output)
+ _convert_substancepainter_project_settings(ayon_settings, output)
_convert_tvpaint_project_settings(ayon_settings, output)
_convert_traypublisher_project_settings(ayon_settings, output)
_convert_webpublisher_project_settings(ayon_settings, output)
@@ -1566,3 +1591,18 @@ def get_ayon_system_settings(default_values):
return convert_system_settings(
ayon_settings, default_values, addon_versions
)
+
+
+def get_ayon_settings(project_name=None):
+ """AYON studio settings.
+
+ Raw AYON settings values.
+
+ Args:
+ project_name (Optional[str]): Project name.
+
+ Returns:
+ dict[str, Any]: AYON settings.
+ """
+
+ return _AyonSettingsCache.get_value_by_project(project_name)
diff --git a/openpype/settings/defaults/project_settings/max.json b/openpype/settings/defaults/project_settings/max.json
index fdaa8d2b91..97fcf69e31 100644
--- a/openpype/settings/defaults/project_settings/max.json
+++ b/openpype/settings/defaults/project_settings/max.json
@@ -51,6 +51,11 @@
"ValidateAttributes": {
"enabled": false,
"attributes": {}
+ },
+ "ValidateLoadedPlugin": {
+ "enabled": false,
+ "optional": true,
+ "family_plugins_mapping": []
}
}
}
diff --git a/openpype/settings/defaults/project_settings/nuke.json b/openpype/settings/defaults/project_settings/nuke.json
index 1cadedd797..20df0ad5c2 100644
--- a/openpype/settings/defaults/project_settings/nuke.json
+++ b/openpype/settings/defaults/project_settings/nuke.json
@@ -19,16 +19,16 @@
"rules": {}
},
"viewer": {
- "viewerProcess": "sRGB"
+ "viewerProcess": "sRGB (default)"
},
"baking": {
- "viewerProcess": "rec709"
+ "viewerProcess": "rec709 (default)"
},
"workfile": {
- "colorManagement": "Nuke",
+ "colorManagement": "OCIO",
"OCIO_config": "nuke-default",
- "workingSpaceLUT": "linear",
- "monitorLut": "sRGB"
+ "workingSpaceLUT": "scene_linear",
+ "monitorLut": "sRGB (default)"
},
"nodes": {
"requiredNodes": [
@@ -76,7 +76,7 @@
{
"type": "text",
"name": "colorspace",
- "value": "linear"
+ "value": "scene_linear"
},
{
"type": "bool",
@@ -129,7 +129,7 @@
{
"type": "text",
"name": "colorspace",
- "value": "linear"
+ "value": "scene_linear"
},
{
"type": "bool",
@@ -177,7 +177,7 @@
{
"type": "text",
"name": "colorspace",
- "value": "sRGB"
+ "value": "texture_paint"
},
{
"type": "bool",
@@ -193,7 +193,7 @@
"inputs": [
{
"regex": "(beauty).*(?=.exr)",
- "colorspace": "linear"
+ "colorspace": "scene_linear"
}
]
}
diff --git a/openpype/settings/entities/schemas/projects_schema/schemas/schema_max_publish.json b/openpype/settings/entities/schemas/projects_schema/schemas/schema_max_publish.json
index c3b56bae5e..c6d37ae993 100644
--- a/openpype/settings/entities/schemas/projects_schema/schemas/schema_max_publish.json
+++ b/openpype/settings/entities/schemas/projects_schema/schemas/schema_max_publish.json
@@ -47,6 +47,49 @@
"label": "Attributes"
}
]
+ },
+ {
+ "type": "dict",
+ "collapsible": true,
+ "key": "ValidateLoadedPlugin",
+ "label": "Validate Loaded Plugin",
+ "checkbox_key": "enabled",
+ "children": [
+ {
+ "type": "boolean",
+ "key": "enabled",
+ "label": "Enabled"
+ },
+ {
+ "type": "boolean",
+ "key": "optional",
+ "label": "Optional"
+ },
+ {
+ "type": "list",
+ "collapsible": true,
+ "key": "family_plugins_mapping",
+ "label": "Family Plugins Mapping",
+ "use_label_wrap": true,
+ "object_type": {
+ "type": "dict",
+ "children": [
+ {
+ "key": "families",
+ "label": "Famiies",
+ "type": "list",
+ "object_type": "text"
+ },
+ {
+ "key": "plugins",
+ "label": "Plugins",
+ "type": "list",
+ "object_type": "text"
+ }
+ ]
+ }
+ }
+ ]
}
]
}
diff --git a/openpype/tools/ayon_launcher/models/actions.py b/openpype/tools/ayon_launcher/models/actions.py
index 93ec115734..d7c4219dc2 100644
--- a/openpype/tools/ayon_launcher/models/actions.py
+++ b/openpype/tools/ayon_launcher/models/actions.py
@@ -402,12 +402,12 @@ class ActionsModel:
)
def _prepare_session(self, project_name, folder_id, task_id):
- folder_name = None
+ folder_path = None
if folder_id:
folder = self._controller.get_folder_entity(
project_name, folder_id)
if folder:
- folder_name = folder["name"]
+ folder_path = folder["path"]
task_name = None
if task_id:
@@ -417,7 +417,7 @@ class ActionsModel:
return {
"AVALON_PROJECT": project_name,
- "AVALON_ASSET": folder_name,
+ "AVALON_ASSET": folder_path,
"AVALON_TASK": task_name,
}
diff --git a/openpype/tools/ayon_loader/control.py b/openpype/tools/ayon_loader/control.py
index 2b779f5c2e..8ec0d96e2e 100644
--- a/openpype/tools/ayon_loader/control.py
+++ b/openpype/tools/ayon_loader/control.py
@@ -1,4 +1,5 @@
import logging
+import uuid
import ayon_api
@@ -289,7 +290,7 @@ class LoaderController(BackendLoaderController, FrontendLoaderController):
project_name = context.get("project_name")
asset_name = context.get("asset_name")
if project_name and asset_name:
- folder = ayon_api.get_folder_by_name(
+ folder = ayon_api.get_folder_by_path(
project_name, asset_name, fields=["id"]
)
if folder:
@@ -314,8 +315,21 @@ class LoaderController(BackendLoaderController, FrontendLoaderController):
containers = self._host.get_containers()
else:
containers = self._host.ls()
- repre_ids = {c.get("representation") for c in containers}
- repre_ids.discard(None)
+ repre_ids = set()
+ for container in containers:
+ repre_id = container.get("representation")
+ # Ignore invalid representation ids.
+ # - invalid representation ids may be available if e.g. is
+ # opened scene from OpenPype whe 'ObjectId' was used instead
+ # of 'uuid'.
+ # NOTE: Server call would crash if there is any invalid id.
+ # That would cause crash we won't get any information.
+ try:
+ uuid.UUID(repre_id)
+ repre_ids.add(repre_id)
+ except ValueError:
+ pass
+
product_ids = self._products_model.get_product_ids_by_repre_ids(
project_name, repre_ids
)
diff --git a/openpype/tools/ayon_loader/models/products.py b/openpype/tools/ayon_loader/models/products.py
index 33023cc164..816dabaf90 100644
--- a/openpype/tools/ayon_loader/models/products.py
+++ b/openpype/tools/ayon_loader/models/products.py
@@ -77,7 +77,15 @@ def product_item_from_entity(
product_attribs = product_entity["attrib"]
group = product_attribs.get("productGroup")
product_type = product_entity["productType"]
- product_type_item = product_type_items_by_name[product_type]
+ product_type_item = product_type_items_by_name.get(product_type)
+ # NOTE This is needed for cases when products were not created on server
+ # using api functions. In that case product type item may not be
+ # available and we need to create a default.
+ if product_type_item is None:
+ product_type_item = create_default_product_type_item(product_type)
+ # Cache the item for future use
+ product_type_items_by_name[product_type] = product_type_item
+
product_type_icon = product_type_item.icon
product_icon = {
@@ -117,6 +125,15 @@ def product_type_item_from_data(product_type_data):
return ProductTypeItem(product_type_data["name"], icon, True)
+def create_default_product_type_item(product_type):
+ icon = {
+ "type": "awesome-font",
+ "name": "fa.folder",
+ "color": "#0091B2",
+ }
+ return ProductTypeItem(product_type, icon, True)
+
+
class ProductsModel:
"""Model for products, version and representation.
diff --git a/openpype/tools/ayon_sceneinventory/control.py b/openpype/tools/ayon_sceneinventory/control.py
index e98b0e307b..6111d7e43b 100644
--- a/openpype/tools/ayon_sceneinventory/control.py
+++ b/openpype/tools/ayon_sceneinventory/control.py
@@ -70,19 +70,12 @@ class SceneInventoryController:
context = self.get_current_context()
project_name = context["project_name"]
- folder_path = context.get("folder_path")
folder_name = context.get("asset_name")
folder_id = None
- if folder_path:
- folder = ayon_api.get_folder_by_path(project_name, folder_path)
+ if folder_name:
+ folder = ayon_api.get_folder_by_path(project_name, folder_name)
if folder:
folder_id = folder["id"]
- elif folder_name:
- for folder in ayon_api.get_folders(
- project_name, folder_names=[folder_name]
- ):
- folder_id = folder["id"]
- break
self._current_folder_id = folder_id
self._current_folder_set = True
diff --git a/openpype/tools/ayon_utils/models/__init__.py b/openpype/tools/ayon_utils/models/__init__.py
index 69722b5e21..8895515b1a 100644
--- a/openpype/tools/ayon_utils/models/__init__.py
+++ b/openpype/tools/ayon_utils/models/__init__.py
@@ -13,6 +13,7 @@ from .hierarchy import (
HIERARCHY_MODEL_SENDER,
)
from .thumbnails import ThumbnailsModel
+from .selection import HierarchyExpectedSelection
__all__ = (
@@ -29,4 +30,6 @@ __all__ = (
"HIERARCHY_MODEL_SENDER",
"ThumbnailsModel",
+
+ "HierarchyExpectedSelection",
)
diff --git a/openpype/tools/ayon_utils/models/cache.py b/openpype/tools/ayon_utils/models/cache.py
index 44b97e930d..221a14160c 100644
--- a/openpype/tools/ayon_utils/models/cache.py
+++ b/openpype/tools/ayon_utils/models/cache.py
@@ -81,11 +81,11 @@ class NestedCacheItem:
"""Helper for cached items stored in nested structure.
Example:
- >>> cache = NestedCacheItem(levels=2)
+ >>> cache = NestedCacheItem(levels=2, default_factory=lambda: 0)
>>> cache["a"]["b"].is_valid
False
>>> cache["a"]["b"].get_data()
- None
+ 0
>>> cache["a"]["b"] = 1
>>> cache["a"]["b"].is_valid
True
@@ -167,8 +167,51 @@ class NestedCacheItem:
return self[key]
+ def cached_count(self):
+ """Amount of cached items.
+
+ Returns:
+ int: Amount of cached items.
+ """
+
+ return len(self._data_by_key)
+
+ def clear_key(self, key):
+ """Clear cached item by key.
+
+ Args:
+ key (str): Key of the cache item.
+ """
+
+ self._data_by_key.pop(key, None)
+
+ def clear_invalid(self):
+ """Clear all invalid cache items.
+
+ Note:
+ To clear all cache items use 'reset'.
+ """
+
+ changed = {}
+ children_are_nested = self._levels > 1
+ for key, cache in tuple(self._data_by_key.items()):
+ if children_are_nested:
+ output = cache.clear_invalid()
+ if output:
+ changed[key] = output
+ if not cache.cached_count():
+ self._data_by_key.pop(key)
+ elif not cache.is_valid:
+ changed[key] = cache.get_data()
+ self._data_by_key.pop(key)
+ return changed
+
def reset(self):
- """Reset cache."""
+ """Reset cache.
+
+ Note:
+ To clear only invalid cache items use 'clear_invalid'.
+ """
self._data_by_key = {}
diff --git a/openpype/tools/ayon_utils/models/selection.py b/openpype/tools/ayon_utils/models/selection.py
new file mode 100644
index 0000000000..0ff239882b
--- /dev/null
+++ b/openpype/tools/ayon_utils/models/selection.py
@@ -0,0 +1,179 @@
+class _ExampleController:
+ def emit_event(self, topic, data, **kwargs):
+ pass
+
+
+class HierarchyExpectedSelection:
+ """Base skeleton of expected selection model.
+
+ Expected selection model holds information about which entities should be
+ selected. The order of selection is very important as change of project
+ will affect what folders are available in folders UI and so on. Because
+ of that should expected selection model know what is current entity
+ to select.
+
+ If any of 'handle_project', 'handle_folder' or 'handle_task' is set to
+ 'False' expected selection data won't contain information about the
+ entity type at all. Also if project is not handled then it is not
+ necessary to call 'expected_project_selected'. Same goes for folder and
+ task.
+
+ Model is triggering event with 'expected_selection_changed' topic and
+ data > data structure is matching 'get_expected_selection_data' method.
+
+ Questions:
+ Require '_ExampleController' as abstraction?
+
+ Args:
+ controller (Any): Controller object. ('_ExampleController')
+ handle_project (bool): Project can be considered as can have expected
+ selection.
+ handle_folder (bool): Folder can be considered as can have expected
+ selection.
+ handle_task (bool): Task can be considered as can have expected
+ selection.
+ """
+
+ def __init__(
+ self,
+ controller,
+ handle_project=True,
+ handle_folder=True,
+ handle_task=True
+ ):
+ self._project_name = None
+ self._folder_id = None
+ self._task_name = None
+
+ self._project_selected = True
+ self._folder_selected = True
+ self._task_selected = True
+
+ self._controller = controller
+
+ self._handle_project = handle_project
+ self._handle_folder = handle_folder
+ self._handle_task = handle_task
+
+ def set_expected_selection(
+ self,
+ project_name=None,
+ folder_id=None,
+ task_name=None
+ ):
+ """Sets expected selection.
+
+ Args:
+ project_name (Optional[str]): Project name.
+ folder_id (Optional[str]): Folder id.
+ task_name (Optional[str]): Task name.
+ """
+
+ self._project_name = project_name
+ self._folder_id = folder_id
+ self._task_name = task_name
+
+ self._project_selected = not self._handle_project
+ self._folder_selected = not self._handle_folder
+ self._task_selected = not self._handle_task
+ self._emit_change()
+
+ def get_expected_selection_data(self):
+ project_current = False
+ folder_current = False
+ task_current = False
+ if not self._project_selected:
+ project_current = True
+ elif not self._folder_selected:
+ folder_current = True
+ elif not self._task_selected:
+ task_current = True
+ data = {}
+ if self._handle_project:
+ data["project"] = {
+ "name": self._project_name,
+ "current": project_current,
+ "selected": self._project_selected,
+ }
+ if self._handle_folder:
+ data["folder"] = {
+ "id": self._folder_id,
+ "current": folder_current,
+ "selected": self._folder_selected,
+ }
+ if self._handle_task:
+ data["task"] = {
+ "name": self._task_name,
+ "current": task_current,
+ "selected": self._task_selected,
+ }
+
+ return data
+
+ def is_expected_project_selected(self, project_name):
+ if not self._handle_project:
+ return True
+ return project_name == self._project_name and self._project_selected
+
+ def is_expected_folder_selected(self, folder_id):
+ if not self._handle_folder:
+ return True
+ return folder_id == self._folder_id and self._folder_selected
+
+ def expected_project_selected(self, project_name):
+ """UI selected requested project.
+
+ Other entity types can be requested for selection.
+
+ Args:
+ project_name (str): Name of project.
+ """
+
+ if project_name != self._project_name:
+ return False
+ self._project_selected = True
+ self._emit_change()
+ return True
+
+ def expected_folder_selected(self, folder_id):
+ """UI selected requested folder.
+
+ Other entity types can be requested for selection.
+
+ Args:
+ folder_id (str): Folder id.
+ """
+
+ if folder_id != self._folder_id:
+ return False
+ self._folder_selected = True
+ self._emit_change()
+ return True
+
+ def expected_task_selected(self, folder_id, task_name):
+ """UI selected requested task.
+
+ Other entity types can be requested for selection.
+
+ Because task name is not unique across project a folder id is also
+ required to confirm the right task has been selected.
+
+ Args:
+ folder_id (str): Folder id.
+ task_name (str): Task name.
+ """
+
+ if self._folder_id != folder_id:
+ return False
+
+ if task_name != self._task_name:
+ return False
+ self._task_selected = True
+ self._emit_change()
+ return True
+
+ def _emit_change(self):
+ self._controller.emit_event(
+ "expected_selection_changed",
+ self.get_expected_selection_data(),
+ )
diff --git a/openpype/tools/ayon_utils/widgets/projects_widget.py b/openpype/tools/ayon_utils/widgets/projects_widget.py
index f98bfcdf8a..728433f929 100644
--- a/openpype/tools/ayon_utils/widgets/projects_widget.py
+++ b/openpype/tools/ayon_utils/widgets/projects_widget.py
@@ -503,17 +503,6 @@ class ProjectsCombobox(QtWidgets.QWidget):
self._projects_model.set_current_context_project(project_name)
self._projects_proxy_model.invalidateFilter()
- def _update_select_item_visiblity(self, **kwargs):
- if not self._select_item_visible:
- return
- if "project_name" not in kwargs:
- project_name = self.get_selected_project_name()
- else:
- project_name = kwargs.get("project_name")
-
- # Hide the item if a project is selected
- self._projects_model.set_selected_project(project_name)
-
def set_select_item_visible(self, visible):
self._select_item_visible = visible
self._projects_model.set_select_item_visible(visible)
@@ -534,6 +523,17 @@ class ProjectsCombobox(QtWidgets.QWidget):
def set_library_filter_enabled(self, enabled):
return self._projects_proxy_model.set_library_filter_enabled(enabled)
+ def _update_select_item_visiblity(self, **kwargs):
+ if not self._select_item_visible:
+ return
+ if "project_name" not in kwargs:
+ project_name = self.get_selected_project_name()
+ else:
+ project_name = kwargs.get("project_name")
+
+ # Hide the item if a project is selected
+ self._projects_model.set_selected_project(project_name)
+
def _on_current_index_changed(self, idx):
if not self._listen_selection_change:
return
diff --git a/openpype/tools/ayon_workfiles/abstract.py b/openpype/tools/ayon_workfiles/abstract.py
index ce399fd4c6..260f701d4b 100644
--- a/openpype/tools/ayon_workfiles/abstract.py
+++ b/openpype/tools/ayon_workfiles/abstract.py
@@ -443,8 +443,11 @@ class AbstractWorkfilesBackend(AbstractWorkfilesCommon):
pass
@abstractmethod
- def get_project_entity(self):
- """Get current project entity.
+ def get_project_entity(self, project_name):
+ """Get project entity by name.
+
+ Args:
+ project_name (str): Project name.
Returns:
dict[str, Any]: Project entity data.
@@ -453,10 +456,11 @@ class AbstractWorkfilesBackend(AbstractWorkfilesCommon):
pass
@abstractmethod
- def get_folder_entity(self, folder_id):
+ def get_folder_entity(self, project_name, folder_id):
"""Get folder entity by id.
Args:
+ project_name (str): Project name.
folder_id (str): Folder id.
Returns:
@@ -466,10 +470,11 @@ class AbstractWorkfilesBackend(AbstractWorkfilesCommon):
pass
@abstractmethod
- def get_task_entity(self, task_id):
+ def get_task_entity(self, project_name, task_id):
"""Get task entity by id.
Args:
+ project_name (str): Project name.
task_id (str): Task id.
Returns:
@@ -574,12 +579,10 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
pass
@abstractmethod
- def set_selected_task(self, folder_id, task_id, task_name):
+ def set_selected_task(self, task_id, task_name):
"""Change selected task.
Args:
- folder_id (Union[str, None]): Folder id or None if no folder
- is selected.
task_id (Union[str, None]): Task id or None if no task
is selected.
task_name (Union[str, None]): Task name or None if no task
@@ -711,21 +714,27 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
pass
@abstractmethod
- def expected_representation_selected(self, representation_id):
+ def expected_representation_selected(
+ self, folder_id, task_name, representation_id
+ ):
"""Expected representation was selected in UI.
Args:
+ folder_id (str): Folder id under which representation is.
+ task_name (str): Task name under which representation is.
representation_id (str): Representation id which was selected.
"""
pass
@abstractmethod
- def expected_workfile_selected(self, workfile_path):
+ def expected_workfile_selected(self, folder_id, task_name, workfile_name):
"""Expected workfile was selected in UI.
Args:
- workfile_path (str): Workfile path which was selected.
+ folder_id (str): Folder id under which workfile is.
+ task_name (str): Task name under which workfile is.
+ workfile_name (str): Workfile filename which was selected.
"""
pass
@@ -738,7 +747,7 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
# Model functions
@abstractmethod
- def get_folder_items(self, sender):
+ def get_folder_items(self, project_name, sender):
"""Folder items to visualize project hierarchy.
This function may trigger events 'folders.refresh.started' and
@@ -746,6 +755,7 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
That may help to avoid re-refresh of folder items in UI elements.
Args:
+ project_name (str): Project name for which are folders requested.
sender (str): Who requested folder items.
Returns:
@@ -756,7 +766,7 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
pass
@abstractmethod
- def get_task_items(self, folder_id, sender):
+ def get_task_items(self, project_name, folder_id, sender):
"""Task items.
This function may trigger events 'tasks.refresh.started' and
@@ -764,6 +774,7 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
That may help to avoid re-refresh of task items in UI elements.
Args:
+ project_name (str): Project name for which are tasks requested.
folder_id (str): Folder ID for which are tasks requested.
sender (str): Who requested folder items.
@@ -892,22 +903,25 @@ class AbstractWorkfilesFrontend(AbstractWorkfilesCommon):
At this moment the only information which can be saved about
workfile is 'note'.
+ When 'note' is 'None' it is only validated if workfile info exists,
+ and if not then creates one with empty note.
+
Args:
folder_id (str): Folder id.
task_id (str): Task id.
filepath (str): Workfile path.
- note (str): Note.
+ note (Union[str, None]): Note.
"""
pass
# General commands
@abstractmethod
- def refresh(self):
- """Refresh everything, models, ui etc.
+ def reset(self):
+ """Reset everything, models, ui etc.
- Triggers 'controller.refresh.started' event at the beginning and
- 'controller.refresh.finished' at the end.
+ Triggers 'controller.reset.started' event at the beginning and
+ 'controller.reset.finished' at the end.
"""
pass
diff --git a/openpype/tools/ayon_workfiles/control.py b/openpype/tools/ayon_workfiles/control.py
index 3784959caf..9d19571267 100644
--- a/openpype/tools/ayon_workfiles/control.py
+++ b/openpype/tools/ayon_workfiles/control.py
@@ -16,93 +16,120 @@ from openpype.pipeline.context_tools import (
)
from openpype.pipeline.workfile import create_workdir_extra_folders
+from openpype.tools.ayon_utils.models import (
+ HierarchyModel,
+ HierarchyExpectedSelection,
+ ProjectsModel,
+)
+
from .abstract import (
AbstractWorkfilesFrontend,
AbstractWorkfilesBackend,
)
-from .models import SelectionModel, EntitiesModel, WorkfilesModel
+from .models import SelectionModel, WorkfilesModel
-class ExpectedSelection:
- def __init__(self):
- self._folder_id = None
- self._task_name = None
+class WorkfilesToolExpectedSelection(HierarchyExpectedSelection):
+ def __init__(self, controller):
+ super(WorkfilesToolExpectedSelection, self).__init__(
+ controller,
+ handle_project=False,
+ handle_folder=True,
+ handle_task=True,
+ )
+
self._workfile_name = None
self._representation_id = None
- self._folder_selected = True
- self._task_selected = True
- self._workfile_name_selected = True
- self._representation_id_selected = True
+
+ self._workfile_selected = True
+ self._representation_selected = True
def set_expected_selection(
self,
- folder_id,
- task_name,
+ project_name=None,
+ folder_id=None,
+ task_name=None,
workfile_name=None,
- representation_id=None
+ representation_id=None,
):
- self._folder_id = folder_id
- self._task_name = task_name
self._workfile_name = workfile_name
self._representation_id = representation_id
- self._folder_selected = False
- self._task_selected = False
- self._workfile_name_selected = workfile_name is None
- self._representation_id_selected = representation_id is None
+
+ self._workfile_selected = False
+ self._representation_selected = False
+
+ super(WorkfilesToolExpectedSelection, self).set_expected_selection(
+ project_name,
+ folder_id,
+ task_name,
+ )
def get_expected_selection_data(self):
- return {
- "folder_id": self._folder_id,
- "task_name": self._task_name,
- "workfile_name": self._workfile_name,
- "representation_id": self._representation_id,
- "folder_selected": self._folder_selected,
- "task_selected": self._task_selected,
- "workfile_name_selected": self._workfile_name_selected,
- "representation_id_selected": self._representation_id_selected,
+ data = super(
+ WorkfilesToolExpectedSelection, self
+ ).get_expected_selection_data()
+
+ _is_current = (
+ self._project_selected
+ and self._folder_selected
+ and self._task_selected
+ )
+ workfile_is_current = False
+ repre_is_current = False
+ if _is_current:
+ workfile_is_current = not self._workfile_selected
+ repre_is_current = not self._representation_selected
+
+ data["workfile"] = {
+ "name": self._workfile_name,
+ "current": workfile_is_current,
+ "selected": self._workfile_selected,
}
+ data["representation"] = {
+ "id": self._representation_id,
+ "current": repre_is_current,
+ "selected": self._workfile_selected,
+ }
+ return data
- def is_expected_folder_selected(self, folder_id):
- return folder_id == self._folder_id and self._folder_selected
+ def is_expected_workfile_selected(self, workfile_name):
+ return (
+ workfile_name == self._workfile_name
+ and self._workfile_selected
+ )
- def is_expected_task_selected(self, folder_id, task_name):
- if not self.is_expected_folder_selected(folder_id):
- return False
- return task_name == self._task_name and self._task_selected
+ def is_expected_representation_selected(self, representation_id):
+ return (
+ representation_id == self._representation_id
+ and self._representation_selected
+ )
- def expected_folder_selected(self, folder_id):
+ def expected_workfile_selected(self, folder_id, task_name, workfile_name):
if folder_id != self._folder_id:
return False
- self._folder_selected = True
- return True
-
- def expected_task_selected(self, folder_id, task_name):
- if not self.is_expected_folder_selected(folder_id):
- return False
if task_name != self._task_name:
return False
- self._task_selected = True
- return True
-
- def expected_workfile_selected(self, folder_id, task_name, workfile_name):
- if not self.is_expected_task_selected(folder_id, task_name):
- return False
-
if workfile_name != self._workfile_name:
return False
- self._workfile_name_selected = True
+ self._workfile_selected = True
+ self._emit_change()
return True
def expected_representation_selected(
self, folder_id, task_name, representation_id
):
- if not self.is_expected_task_selected(folder_id, task_name):
+ if folder_id != self._folder_id:
return False
+
+ if task_name != self._task_name:
+ return False
+
if representation_id != self._representation_id:
return False
- self._representation_id_selected = True
+ self._representation_selected = True
+ self._emit_change()
return True
@@ -136,9 +163,9 @@ class BaseWorkfileController(
# Expected selected folder and task
self._expected_selection = self._create_expected_selection_obj()
-
self._selection_model = self._create_selection_model()
- self._entities_model = self._create_entities_model()
+ self._projects_model = self._create_projects_model()
+ self._hierarchy_model = self._create_hierarchy_model()
self._workfiles_model = self._create_workfiles_model()
@property
@@ -151,13 +178,16 @@ class BaseWorkfileController(
return self._host_is_valid
def _create_expected_selection_obj(self):
- return ExpectedSelection()
+ return WorkfilesToolExpectedSelection(self)
+
+ def _create_projects_model(self):
+ return ProjectsModel(self)
def _create_selection_model(self):
return SelectionModel(self)
- def _create_entities_model(self):
- return EntitiesModel(self)
+ def _create_hierarchy_model(self):
+ return HierarchyModel(self)
def _create_workfiles_model(self):
return WorkfilesModel(self)
@@ -193,14 +223,17 @@ class BaseWorkfileController(
self._project_anatomy = Anatomy(self.get_current_project_name())
return self._project_anatomy
- def get_project_entity(self):
- return self._entities_model.get_project_entity()
+ def get_project_entity(self, project_name):
+ return self._projects_model.get_project_entity(
+ project_name)
- def get_folder_entity(self, folder_id):
- return self._entities_model.get_folder_entity(folder_id)
+ def get_folder_entity(self, project_name, folder_id):
+ return self._hierarchy_model.get_folder_entity(
+ project_name, folder_id)
- def get_task_entity(self, task_id):
- return self._entities_model.get_task_entity(task_id)
+ def get_task_entity(self, project_name, task_id):
+ return self._hierarchy_model.get_task_entity(
+ project_name, task_id)
# ---------------------------------
# Implementation of abstract methods
@@ -293,9 +326,8 @@ class BaseWorkfileController(
def get_selected_task_name(self):
return self._selection_model.get_selected_task_name()
- def set_selected_task(self, folder_id, task_id, task_name):
- return self._selection_model.set_selected_task(
- folder_id, task_id, task_name)
+ def set_selected_task(self, task_id, task_name):
+ return self._selection_model.set_selected_task(task_id, task_name)
def get_selected_workfile_path(self):
return self._selection_model.get_selected_workfile_path()
@@ -318,7 +350,11 @@ class BaseWorkfileController(
representation_id=None
):
self._expected_selection.set_expected_selection(
- folder_id, task_name, workfile_name, representation_id
+ self.get_current_project_name(),
+ folder_id,
+ task_name,
+ workfile_name,
+ representation_id
)
self._trigger_expected_selection_changed()
@@ -355,11 +391,13 @@ class BaseWorkfileController(
)
# Model functions
- def get_folder_items(self, sender):
- return self._entities_model.get_folder_items(sender)
+ def get_folder_items(self, project_name, sender=None):
+ return self._hierarchy_model.get_folder_items(project_name, sender)
- def get_task_items(self, folder_id, sender):
- return self._entities_model.get_tasks_items(folder_id, sender)
+ def get_task_items(self, project_name, folder_id, sender=None):
+ return self._hierarchy_model.get_task_items(
+ project_name, folder_id, sender
+ )
def get_workarea_dir_by_context(self, folder_id, task_id):
return self._workfiles_model.get_workarea_dir_by_context(
@@ -394,7 +432,9 @@ class BaseWorkfileController(
def get_published_file_items(self, folder_id, task_id):
task_name = None
if task_id:
- task = self.get_task_entity(task_id)
+ task = self.get_task_entity(
+ self.get_current_project_name(), task_id
+ )
task_name = task.get("name")
return self._workfiles_model.get_published_file_items(
@@ -410,24 +450,30 @@ class BaseWorkfileController(
folder_id, task_id, filepath, note
)
- def refresh(self):
+ def reset(self):
if not self._host_is_valid:
- self._emit_event("controller.refresh.started")
- self._emit_event("controller.refresh.finished")
+ self._emit_event("controller.reset.started")
+ self._emit_event("controller.reset.finished")
return
expected_folder_id = self.get_selected_folder_id()
expected_task_name = self.get_selected_task_name()
+ expected_work_path = self.get_selected_workfile_path()
+ expected_repre_id = self.get_selected_representation_id()
+ expected_work_name = None
+ if expected_work_path:
+ expected_work_name = os.path.basename(expected_work_path)
- self._emit_event("controller.refresh.started")
+ self._emit_event("controller.reset.started")
context = self._get_host_current_context()
project_name = context["project_name"]
folder_name = context["asset_name"]
task_name = context["task_name"]
+ current_file = self.get_current_workfile()
folder_id = None
if folder_name:
- folder = ayon_api.get_folder_by_name(project_name, folder_name)
+ folder = ayon_api.get_folder_by_path(project_name, folder_name)
if folder:
folder_id = folder["id"]
@@ -439,18 +485,25 @@ class BaseWorkfileController(
self._current_folder_id = folder_id
self._current_task_name = task_name
+ self._projects_model.reset()
+ self._hierarchy_model.reset()
+
if not expected_folder_id:
expected_folder_id = folder_id
expected_task_name = task_name
+ if current_file:
+ expected_work_name = os.path.basename(current_file)
+
+ self._emit_event("controller.reset.finished")
self._expected_selection.set_expected_selection(
- expected_folder_id, expected_task_name
+ project_name,
+ expected_folder_id,
+ expected_task_name,
+ expected_work_name,
+ expected_repre_id,
)
- self._entities_model.refresh()
-
- self._emit_event("controller.refresh.finished")
-
# Controller actions
def open_workfile(self, folder_id, task_id, filepath):
self._emit_event("open_workfile.started")
@@ -579,9 +632,9 @@ class BaseWorkfileController(
self, project_name, folder_id, task_id, folder=None, task=None
):
if folder is None:
- folder = self.get_folder_entity(folder_id)
+ folder = self.get_folder_entity(project_name, folder_id)
if task is None:
- task = self.get_task_entity(task_id)
+ task = self.get_task_entity(project_name, task_id)
# NOTE keys should be OpenPype compatible
return {
"project_name": project_name,
@@ -633,8 +686,8 @@ class BaseWorkfileController(
):
# Trigger before save event
project_name = self.get_current_project_name()
- folder = self.get_folder_entity(folder_id)
- task = self.get_task_entity(task_id)
+ folder = self.get_folder_entity(project_name, folder_id)
+ task = self.get_task_entity(project_name, task_id)
task_name = task["name"]
# QUESTION should the data be different for 'before' and 'after'?
@@ -674,6 +727,9 @@ class BaseWorkfileController(
else:
self._host_save_workfile(dst_filepath)
+ # Make sure workfile info exists
+ self.save_workfile_info(folder_id, task_id, dst_filepath, None)
+
# Create extra folders
create_workdir_extra_folders(
workdir,
@@ -685,4 +741,4 @@ class BaseWorkfileController(
# Trigger after save events
emit_event("workfile.save.after", event_data, source="workfiles.tool")
- self.refresh()
+ self.reset()
diff --git a/openpype/tools/ayon_workfiles/models/__init__.py b/openpype/tools/ayon_workfiles/models/__init__.py
index d906b9e7bd..734cb08cb6 100644
--- a/openpype/tools/ayon_workfiles/models/__init__.py
+++ b/openpype/tools/ayon_workfiles/models/__init__.py
@@ -1,10 +1,8 @@
-from .hierarchy import EntitiesModel
from .selection import SelectionModel
from .workfiles import WorkfilesModel
__all__ = (
"SelectionModel",
- "EntitiesModel",
"WorkfilesModel",
)
diff --git a/openpype/tools/ayon_workfiles/models/hierarchy.py b/openpype/tools/ayon_workfiles/models/hierarchy.py
deleted file mode 100644
index a1d51525da..0000000000
--- a/openpype/tools/ayon_workfiles/models/hierarchy.py
+++ /dev/null
@@ -1,236 +0,0 @@
-"""Hierarchy model that handles folders and tasks.
-
-The model can be extracted for common usage. In that case it will be required
-to add more handling of project name changes.
-"""
-
-import time
-import collections
-import contextlib
-
-import ayon_api
-
-from openpype.tools.ayon_workfiles.abstract import (
- FolderItem,
- TaskItem,
-)
-
-
-def _get_task_items_from_tasks(tasks):
- """
-
- Returns:
- TaskItem: Task item.
- """
-
- output = []
- for task in tasks:
- folder_id = task["folderId"]
- output.append(TaskItem(
- task["id"],
- task["name"],
- task["type"],
- folder_id,
- None,
- None
- ))
- return output
-
-
-def _get_folder_item_from_hierarchy_item(item):
- return FolderItem(
- item["id"],
- item["parentId"],
- item["name"],
- item["label"],
- None,
- None,
- )
-
-
-class CacheItem:
- def __init__(self, lifetime=120):
- self._lifetime = lifetime
- self._last_update = None
- self._data = None
-
- @property
- def is_valid(self):
- if self._last_update is None:
- return False
-
- return (time.time() - self._last_update) < self._lifetime
-
- def set_invalid(self, data=None):
- self._last_update = None
- self._data = data
-
- def get_data(self):
- return self._data
-
- def update_data(self, data):
- self._data = data
- self._last_update = time.time()
-
-
-class EntitiesModel(object):
- event_source = "entities.model"
-
- def __init__(self, controller):
- project_cache = CacheItem()
- project_cache.set_invalid({})
- folders_cache = CacheItem()
- folders_cache.set_invalid({})
- self._project_cache = project_cache
- self._folders_cache = folders_cache
- self._tasks_cache = {}
-
- self._folders_by_id = {}
- self._tasks_by_id = {}
-
- self._folders_refreshing = False
- self._tasks_refreshing = set()
- self._controller = controller
-
- def reset(self):
- self._project_cache.set_invalid({})
- self._folders_cache.set_invalid({})
- self._tasks_cache = {}
-
- self._folders_by_id = {}
- self._tasks_by_id = {}
-
- def refresh(self):
- self._refresh_folders_cache()
-
- def get_project_entity(self):
- if not self._project_cache.is_valid:
- project_name = self._controller.get_current_project_name()
- project_entity = ayon_api.get_project(project_name)
- self._project_cache.update_data(project_entity)
- return self._project_cache.get_data()
-
- def get_folder_items(self, sender):
- if not self._folders_cache.is_valid:
- self._refresh_folders_cache(sender)
- return self._folders_cache.get_data()
-
- def get_tasks_items(self, folder_id, sender):
- if not folder_id:
- return []
-
- task_cache = self._tasks_cache.get(folder_id)
- if task_cache is None or not task_cache.is_valid:
- self._refresh_tasks_cache(folder_id, sender)
- task_cache = self._tasks_cache.get(folder_id)
- return task_cache.get_data()
-
- def get_folder_entity(self, folder_id):
- if folder_id not in self._folders_by_id:
- entity = None
- if folder_id:
- project_name = self._controller.get_current_project_name()
- entity = ayon_api.get_folder_by_id(project_name, folder_id)
- self._folders_by_id[folder_id] = entity
- return self._folders_by_id[folder_id]
-
- def get_task_entity(self, task_id):
- if task_id not in self._tasks_by_id:
- entity = None
- if task_id:
- project_name = self._controller.get_current_project_name()
- entity = ayon_api.get_task_by_id(project_name, task_id)
- self._tasks_by_id[task_id] = entity
- return self._tasks_by_id[task_id]
-
- @contextlib.contextmanager
- def _folder_refresh_event_manager(self, project_name, sender):
- self._folders_refreshing = True
- self._controller.emit_event(
- "folders.refresh.started",
- {"project_name": project_name, "sender": sender},
- self.event_source
- )
- try:
- yield
-
- finally:
- self._controller.emit_event(
- "folders.refresh.finished",
- {"project_name": project_name, "sender": sender},
- self.event_source
- )
- self._folders_refreshing = False
-
- @contextlib.contextmanager
- def _task_refresh_event_manager(
- self, project_name, folder_id, sender
- ):
- self._tasks_refreshing.add(folder_id)
- self._controller.emit_event(
- "tasks.refresh.started",
- {
- "project_name": project_name,
- "folder_id": folder_id,
- "sender": sender,
- },
- self.event_source
- )
- try:
- yield
-
- finally:
- self._controller.emit_event(
- "tasks.refresh.finished",
- {
- "project_name": project_name,
- "folder_id": folder_id,
- "sender": sender,
- },
- self.event_source
- )
- self._tasks_refreshing.discard(folder_id)
-
- def _refresh_folders_cache(self, sender=None):
- if self._folders_refreshing:
- return
- project_name = self._controller.get_current_project_name()
- with self._folder_refresh_event_manager(project_name, sender):
- folder_items = self._query_folders(project_name)
- self._folders_cache.update_data(folder_items)
-
- def _query_folders(self, project_name):
- hierarchy = ayon_api.get_folders_hierarchy(project_name)
-
- folder_items = {}
- hierachy_queue = collections.deque(hierarchy["hierarchy"])
- while hierachy_queue:
- item = hierachy_queue.popleft()
- folder_item = _get_folder_item_from_hierarchy_item(item)
- folder_items[folder_item.entity_id] = folder_item
- hierachy_queue.extend(item["children"] or [])
- return folder_items
-
- def _refresh_tasks_cache(self, folder_id, sender=None):
- if folder_id in self._tasks_refreshing:
- return
-
- project_name = self._controller.get_current_project_name()
- with self._task_refresh_event_manager(
- project_name, folder_id, sender
- ):
- cache_item = self._tasks_cache.get(folder_id)
- if cache_item is None:
- cache_item = CacheItem()
- self._tasks_cache[folder_id] = cache_item
-
- task_items = self._query_tasks(project_name, folder_id)
- cache_item.update_data(task_items)
-
- def _query_tasks(self, project_name, folder_id):
- tasks = list(ayon_api.get_tasks(
- project_name,
- folder_ids=[folder_id],
- fields={"id", "name", "label", "folderId", "type"}
- ))
- return _get_task_items_from_tasks(tasks)
diff --git a/openpype/tools/ayon_workfiles/models/selection.py b/openpype/tools/ayon_workfiles/models/selection.py
index ad034794d8..2f0896842d 100644
--- a/openpype/tools/ayon_workfiles/models/selection.py
+++ b/openpype/tools/ayon_workfiles/models/selection.py
@@ -4,7 +4,7 @@ class SelectionModel(object):
Triggering events:
- "selection.folder.changed"
- "selection.task.changed"
- - "workarea.selection.changed"
+ - "selection.workarea.changed"
- "selection.representation.changed"
"""
@@ -29,7 +29,10 @@ class SelectionModel(object):
self._folder_id = folder_id
self._controller.emit_event(
"selection.folder.changed",
- {"folder_id": folder_id},
+ {
+ "project_name": self._controller.get_current_project_name(),
+ "folder_id": folder_id
+ },
self.event_source
)
@@ -39,10 +42,7 @@ class SelectionModel(object):
def get_selected_task_id(self):
return self._task_id
- def set_selected_task(self, folder_id, task_id, task_name):
- if folder_id != self._folder_id:
- self.set_selected_folder(folder_id)
-
+ def set_selected_task(self, task_id, task_name):
if task_id == self._task_id:
return
@@ -51,7 +51,8 @@ class SelectionModel(object):
self._controller.emit_event(
"selection.task.changed",
{
- "folder_id": folder_id,
+ "project_name": self._controller.get_current_project_name(),
+ "folder_id": self._folder_id,
"task_name": task_name,
"task_id": task_id
},
@@ -67,8 +68,9 @@ class SelectionModel(object):
self._workfile_path = path
self._controller.emit_event(
- "workarea.selection.changed",
+ "selection.workarea.changed",
{
+ "project_name": self._controller.get_current_project_name(),
"path": path,
"folder_id": self._folder_id,
"task_name": self._task_name,
@@ -86,6 +88,9 @@ class SelectionModel(object):
self._representation_id = representation_id
self._controller.emit_event(
"selection.representation.changed",
- {"representation_id": representation_id},
+ {
+ "project_name": self._controller.get_current_project_name(),
+ "representation_id": representation_id,
+ },
self.event_source
)
diff --git a/openpype/tools/ayon_workfiles/models/workfiles.py b/openpype/tools/ayon_workfiles/models/workfiles.py
index 4d989ed22c..907b9b5383 100644
--- a/openpype/tools/ayon_workfiles/models/workfiles.py
+++ b/openpype/tools/ayon_workfiles/models/workfiles.py
@@ -148,7 +148,9 @@ class WorkareaModel:
def _get_folder_data(self, folder_id):
fill_data = self._fill_data_by_folder_id.get(folder_id)
if fill_data is None:
- folder = self._controller.get_folder_entity(folder_id)
+ folder = self._controller.get_folder_entity(
+ self.project_name, folder_id
+ )
fill_data = get_folder_template_data(folder)
self._fill_data_by_folder_id[folder_id] = fill_data
return copy.deepcopy(fill_data)
@@ -156,7 +158,9 @@ class WorkareaModel:
def _get_task_data(self, project_entity, folder_id, task_id):
task_data = self._task_data_by_folder_id.setdefault(folder_id, {})
if task_id not in task_data:
- task = self._controller.get_task_entity(task_id)
+ task = self._controller.get_task_entity(
+ self.project_name, task_id
+ )
if task:
task_data[task_id] = get_task_template_data(
project_entity, task)
@@ -167,8 +171,9 @@ class WorkareaModel:
return {}
base_data = self._get_base_data()
+ project_name = base_data["project"]["name"]
folder_data = self._get_folder_data(folder_id)
- project_entity = self._controller.get_project_entity()
+ project_entity = self._controller.get_project_entity(project_name)
task_data = self._get_task_data(project_entity, folder_id, task_id)
base_data.update(folder_data)
@@ -292,9 +297,13 @@ class WorkareaModel:
folder = None
task = None
if folder_id:
- folder = self._controller.get_folder_entity(folder_id)
+ folder = self._controller.get_folder_entity(
+ self.project_name, folder_id
+ )
if task_id:
- task = self._controller.get_task_entity(task_id)
+ task = self._controller.get_task_entity(
+ self.project_name, task_id
+ )
if not folder or not task:
return {
@@ -491,10 +500,13 @@ class WorkfileEntitiesModel:
)
if not workfile_info:
self._cache[identifier] = self._create_workfile_info_entity(
- task_id, rootless_path, note)
+ task_id, rootless_path, note or "")
self._items.pop(identifier, None)
return
+ if note is None:
+ return
+
new_workfile_info = copy.deepcopy(workfile_info)
attrib = new_workfile_info.setdefault("attrib", {})
attrib["description"] = note
diff --git a/openpype/tools/ayon_workfiles/widgets/files_widget.py b/openpype/tools/ayon_workfiles/widgets/files_widget.py
index 656ddf1dd8..16f0b6fce3 100644
--- a/openpype/tools/ayon_workfiles/widgets/files_widget.py
+++ b/openpype/tools/ayon_workfiles/widgets/files_widget.py
@@ -69,7 +69,7 @@ class FilesWidget(QtWidgets.QWidget):
main_layout.addWidget(btns_widget, 0)
controller.register_event_callback(
- "workarea.selection.changed",
+ "selection.workarea.changed",
self._on_workarea_path_changed
)
controller.register_event_callback(
diff --git a/openpype/tools/ayon_workfiles/widgets/files_widget_published.py b/openpype/tools/ayon_workfiles/widgets/files_widget_published.py
index 576cf18d73..704f7b2f39 100644
--- a/openpype/tools/ayon_workfiles/widgets/files_widget_published.py
+++ b/openpype/tools/ayon_workfiles/widgets/files_widget_published.py
@@ -59,14 +59,6 @@ class PublishedFilesModel(QtGui.QStandardItemModel):
self._add_empty_item()
- def _clear_items(self):
- self._remove_missing_context_item()
- self._remove_empty_item()
- if self._items_by_id:
- root = self.invisibleRootItem()
- root.removeRows(0, root.rowCount())
- self._items_by_id = {}
-
def set_published_mode(self, published_mode):
if self._published_mode == published_mode:
return
@@ -89,6 +81,18 @@ class PublishedFilesModel(QtGui.QStandardItemModel):
return QtCore.QModelIndex()
return self.indexFromItem(item)
+ def refresh(self):
+ if self._published_mode:
+ self._fill_items()
+
+ def _clear_items(self):
+ self._remove_missing_context_item()
+ self._remove_empty_item()
+ if self._items_by_id:
+ root = self.invisibleRootItem()
+ root.removeRows(0, root.rowCount())
+ self._items_by_id = {}
+
def _get_missing_context_item(self):
if self._missing_context_item is None:
message = "Select folder"
@@ -149,7 +153,6 @@ class PublishedFilesModel(QtGui.QStandardItemModel):
def _on_folder_changed(self, event):
self._last_folder_id = event["folder_id"]
- self._last_task_id = None
if self._context_select_mode:
return
@@ -356,14 +359,13 @@ class PublishedFilesWidget(QtWidgets.QWidget):
self.save_as_requested.emit()
def _on_expected_selection_change(self, event):
- if (
- event["representation_id_selected"]
- or not event["folder_selected"]
- or (event["task_name"] and not event["task_selected"])
- ):
+ repre_info = event["representation"]
+ if not repre_info["current"]:
return
- representation_id = event["representation_id"]
+ self._model.refresh()
+
+ representation_id = repre_info["id"]
selected_repre_id = self.get_selected_repre_id()
if (
representation_id is not None
@@ -376,5 +378,5 @@ class PublishedFilesWidget(QtWidgets.QWidget):
self._view.setCurrentIndex(proxy_index)
self._controller.expected_representation_selected(
- event["folder_id"], event["task_name"], representation_id
+ event["folder"]["id"], event["task"]["name"], representation_id
)
diff --git a/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py b/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py
index 3a8e90f933..8eefd3cf81 100644
--- a/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py
+++ b/openpype/tools/ayon_workfiles/widgets/files_widget_workarea.py
@@ -28,6 +28,10 @@ class WorkAreaFilesModel(QtGui.QStandardItemModel):
self.setHeaderData(0, QtCore.Qt.Horizontal, "Name")
self.setHeaderData(1, QtCore.Qt.Horizontal, "Date Modified")
+ controller.register_event_callback(
+ "selection.folder.changed",
+ self._on_folder_changed
+ )
controller.register_event_callback(
"selection.task.changed",
self._on_task_changed
@@ -63,6 +67,10 @@ class WorkAreaFilesModel(QtGui.QStandardItemModel):
return QtCore.QModelIndex()
return self.indexFromItem(item)
+ def refresh(self):
+ if not self._published_mode:
+ self._fill_items()
+
def _get_missing_context_item(self):
if self._missing_context_item is None:
message = "Select folder and task"
@@ -129,6 +137,11 @@ class WorkAreaFilesModel(QtGui.QStandardItemModel):
root_item.takeRow(self._empty_root_item.row())
self._empty_item_used = False
+ def _on_folder_changed(self, event):
+ self._selected_folder_id = event["folder_id"]
+ if not self._published_mode:
+ self._fill_items()
+
def _on_task_changed(self, event):
self._selected_folder_id = event["folder_id"]
self._selected_task_id = event["task_id"]
@@ -362,10 +375,13 @@ class WorkAreaFilesWidget(QtWidgets.QWidget):
self.duplicate_requested.emit()
def _on_expected_selection_change(self, event):
- if event["workfile_name_selected"]:
+ workfile_info = event["workfile"]
+ if not workfile_info["current"]:
return
- workfile_name = event["workfile_name"]
+ self._model.refresh()
+
+ workfile_name = workfile_info["name"]
if (
workfile_name is not None
and workfile_name != self._get_selected_info()["filename"]
@@ -376,5 +392,5 @@ class WorkAreaFilesWidget(QtWidgets.QWidget):
self._view.setCurrentIndex(proxy_index)
self._controller.expected_workfile_selected(
- event["folder_id"], event["task_name"], workfile_name
+ event["folder"]["id"], event["task"]["name"], workfile_name
)
diff --git a/openpype/tools/ayon_workfiles/widgets/folders_widget.py b/openpype/tools/ayon_workfiles/widgets/folders_widget.py
deleted file mode 100644
index b04f8e4098..0000000000
--- a/openpype/tools/ayon_workfiles/widgets/folders_widget.py
+++ /dev/null
@@ -1,324 +0,0 @@
-import uuid
-import collections
-
-import qtawesome
-from qtpy import QtWidgets, QtGui, QtCore
-
-from openpype.tools.utils import (
- RecursiveSortFilterProxyModel,
- DeselectableTreeView,
-)
-
-from .constants import ITEM_ID_ROLE, ITEM_NAME_ROLE
-
-SENDER_NAME = "qt_folders_model"
-
-
-class FoldersRefreshThread(QtCore.QThread):
- """Thread for refreshing folders.
-
- Call controller to get folders and emit signal when finished.
-
- Args:
- controller (AbstractWorkfilesFrontend): The control object.
- """
-
- refresh_finished = QtCore.Signal(str)
-
- def __init__(self, controller):
- super(FoldersRefreshThread, self).__init__()
- self._id = uuid.uuid4().hex
- self._controller = controller
- self._result = None
-
- @property
- def id(self):
- """Thread id.
-
- Returns:
- str: Unique id of the thread.
- """
-
- return self._id
-
- def run(self):
- self._result = self._controller.get_folder_items(SENDER_NAME)
- self.refresh_finished.emit(self.id)
-
- def get_result(self):
- return self._result
-
-
-class FoldersModel(QtGui.QStandardItemModel):
- """Folders model which cares about refresh of folders.
-
- Args:
- controller (AbstractWorkfilesFrontend): The control object.
- """
-
- refreshed = QtCore.Signal()
-
- def __init__(self, controller):
- super(FoldersModel, self).__init__()
-
- self._controller = controller
- self._items_by_id = {}
- self._parent_id_by_id = {}
-
- self._refresh_threads = {}
- self._current_refresh_thread = None
-
- self._has_content = False
- self._is_refreshing = False
-
- @property
- def is_refreshing(self):
- """Model is refreshing.
-
- Returns:
- bool: True if model is refreshing.
- """
- return self._is_refreshing
-
- @property
- def has_content(self):
- """Has at least one folder.
-
- Returns:
- bool: True if model has at least one folder.
- """
-
- return self._has_content
-
- def clear(self):
- self._items_by_id = {}
- self._parent_id_by_id = {}
- self._has_content = False
- super(FoldersModel, self).clear()
-
- def get_index_by_id(self, item_id):
- """Get index by folder id.
-
- Returns:
- QtCore.QModelIndex: Index of the folder. Can be invalid if folder
- is not available.
- """
- item = self._items_by_id.get(item_id)
- if item is None:
- return QtCore.QModelIndex()
- return self.indexFromItem(item)
-
- def refresh(self):
- """Refresh folders items.
-
- Refresh start thread because it can cause that controller can
- start query from database if folders are not cached.
- """
-
- self._is_refreshing = True
-
- thread = FoldersRefreshThread(self._controller)
- self._current_refresh_thread = thread.id
- self._refresh_threads[thread.id] = thread
- thread.refresh_finished.connect(self._on_refresh_thread)
- thread.start()
-
- def _on_refresh_thread(self, thread_id):
- """Callback when refresh thread is finished.
-
- Technically can be running multiple refresh threads at the same time,
- to avoid using values from wrong thread, we check if thread id is
- current refresh thread id.
-
- Folders are stored by id.
-
- Args:
- thread_id (str): Thread id.
- """
-
- thread = self._refresh_threads.pop(thread_id)
- if thread_id != self._current_refresh_thread:
- return
-
- folder_items_by_id = thread.get_result()
- if not folder_items_by_id:
- if folder_items_by_id is not None:
- self.clear()
- self._is_refreshing = False
- return
-
- self._has_content = True
-
- folder_ids = set(folder_items_by_id)
- ids_to_remove = set(self._items_by_id) - folder_ids
-
- folder_items_by_parent = collections.defaultdict(list)
- for folder_item in folder_items_by_id.values():
- folder_items_by_parent[folder_item.parent_id].append(folder_item)
-
- hierarchy_queue = collections.deque()
- hierarchy_queue.append(None)
-
- while hierarchy_queue:
- parent_id = hierarchy_queue.popleft()
- folder_items = folder_items_by_parent[parent_id]
- if parent_id is None:
- parent_item = self.invisibleRootItem()
- else:
- parent_item = self._items_by_id[parent_id]
-
- new_items = []
- for folder_item in folder_items:
- item_id = folder_item.entity_id
- item = self._items_by_id.get(item_id)
- if item is None:
- is_new = True
- item = QtGui.QStandardItem()
- item.setEditable(False)
- else:
- is_new = self._parent_id_by_id[item_id] != parent_id
-
- icon = qtawesome.icon(
- folder_item.icon_name,
- color=folder_item.icon_color,
- )
- item.setData(item_id, ITEM_ID_ROLE)
- item.setData(folder_item.name, ITEM_NAME_ROLE)
- item.setData(folder_item.label, QtCore.Qt.DisplayRole)
- item.setData(icon, QtCore.Qt.DecorationRole)
- if is_new:
- new_items.append(item)
- self._items_by_id[item_id] = item
- self._parent_id_by_id[item_id] = parent_id
-
- hierarchy_queue.append(item_id)
-
- if new_items:
- parent_item.appendRows(new_items)
-
- for item_id in ids_to_remove:
- item = self._items_by_id[item_id]
- parent_id = self._parent_id_by_id[item_id]
- if parent_id is None:
- parent_item = self.invisibleRootItem()
- else:
- parent_item = self._items_by_id[parent_id]
- parent_item.takeChild(item.row())
-
- for item_id in ids_to_remove:
- self._items_by_id.pop(item_id)
- self._parent_id_by_id.pop(item_id)
-
- self._is_refreshing = False
- self.refreshed.emit()
-
-
-class FoldersWidget(QtWidgets.QWidget):
- """Folders widget.
-
- Widget that handles folders view, model and selection.
-
- Args:
- controller (AbstractWorkfilesFrontend): The control object.
- parent (QtWidgets.QWidget): The parent widget.
- """
-
- def __init__(self, controller, parent):
- super(FoldersWidget, self).__init__(parent)
-
- folders_view = DeselectableTreeView(self)
- folders_view.setHeaderHidden(True)
-
- folders_model = FoldersModel(controller)
- folders_proxy_model = RecursiveSortFilterProxyModel()
- folders_proxy_model.setSourceModel(folders_model)
-
- folders_view.setModel(folders_proxy_model)
-
- main_layout = QtWidgets.QHBoxLayout(self)
- main_layout.setContentsMargins(0, 0, 0, 0)
- main_layout.addWidget(folders_view, 1)
-
- controller.register_event_callback(
- "folders.refresh.finished",
- self._on_folders_refresh_finished
- )
- controller.register_event_callback(
- "controller.refresh.finished",
- self._on_controller_refresh
- )
- controller.register_event_callback(
- "expected_selection_changed",
- self._on_expected_selection_change
- )
-
- selection_model = folders_view.selectionModel()
- selection_model.selectionChanged.connect(self._on_selection_change)
-
- folders_model.refreshed.connect(self._on_model_refresh)
-
- self._controller = controller
- self._folders_view = folders_view
- self._folders_model = folders_model
- self._folders_proxy_model = folders_proxy_model
-
- self._expected_selection = None
-
- def set_name_filter(self, name):
- self._folders_proxy_model.setFilterFixedString(name)
-
- def _clear(self):
- self._folders_model.clear()
-
- def _on_folders_refresh_finished(self, event):
- if event["sender"] != SENDER_NAME:
- self._folders_model.refresh()
-
- def _on_controller_refresh(self):
- self._update_expected_selection()
-
- def _update_expected_selection(self, expected_data=None):
- if expected_data is None:
- expected_data = self._controller.get_expected_selection_data()
-
- # We're done
- if expected_data["folder_selected"]:
- return
-
- folder_id = expected_data["folder_id"]
- self._expected_selection = folder_id
- if not self._folders_model.is_refreshing:
- self._set_expected_selection()
-
- def _set_expected_selection(self):
- folder_id = self._expected_selection
- self._expected_selection = None
- if (
- folder_id is not None
- and folder_id != self._get_selected_item_id()
- ):
- index = self._folders_model.get_index_by_id(folder_id)
- if index.isValid():
- proxy_index = self._folders_proxy_model.mapFromSource(index)
- self._folders_view.setCurrentIndex(proxy_index)
- self._controller.expected_folder_selected(folder_id)
-
- def _on_model_refresh(self):
- if self._expected_selection:
- self._set_expected_selection()
- self._folders_proxy_model.sort(0)
-
- def _on_expected_selection_change(self, event):
- self._update_expected_selection(event.data)
-
- def _get_selected_item_id(self):
- selection_model = self._folders_view.selectionModel()
- for index in selection_model.selectedIndexes():
- item_id = index.data(ITEM_ID_ROLE)
- if item_id is not None:
- return item_id
- return None
-
- def _on_selection_change(self):
- item_id = self._get_selected_item_id()
- self._controller.set_selected_folder(item_id)
diff --git a/openpype/tools/ayon_workfiles/widgets/side_panel.py b/openpype/tools/ayon_workfiles/widgets/side_panel.py
index 7f06576a00..5085f4701e 100644
--- a/openpype/tools/ayon_workfiles/widgets/side_panel.py
+++ b/openpype/tools/ayon_workfiles/widgets/side_panel.py
@@ -66,7 +66,7 @@ class SidePanelWidget(QtWidgets.QWidget):
btn_note_save.clicked.connect(self._on_save_click)
controller.register_event_callback(
- "workarea.selection.changed", self._on_selection_change
+ "selection.workarea.changed", self._on_selection_change
)
self._details_input = details_input
diff --git a/openpype/tools/ayon_workfiles/widgets/tasks_widget.py b/openpype/tools/ayon_workfiles/widgets/tasks_widget.py
deleted file mode 100644
index 04f5b286b1..0000000000
--- a/openpype/tools/ayon_workfiles/widgets/tasks_widget.py
+++ /dev/null
@@ -1,420 +0,0 @@
-import uuid
-import qtawesome
-from qtpy import QtWidgets, QtGui, QtCore
-
-from openpype.style import get_disabled_entity_icon_color
-from openpype.tools.utils import DeselectableTreeView
-
-from .constants import (
- ITEM_NAME_ROLE,
- ITEM_ID_ROLE,
- PARENT_ID_ROLE,
-)
-
-SENDER_NAME = "qt_tasks_model"
-
-
-class RefreshThread(QtCore.QThread):
- """Thread for refreshing tasks.
-
- Call controller to get tasks and emit signal when finished.
-
- Args:
- controller (AbstractWorkfilesFrontend): The control object.
- folder_id (str): Folder id.
- """
-
- refresh_finished = QtCore.Signal(str)
-
- def __init__(self, controller, folder_id):
- super(RefreshThread, self).__init__()
- self._id = uuid.uuid4().hex
- self._controller = controller
- self._folder_id = folder_id
- self._result = None
-
- @property
- def id(self):
- return self._id
-
- def run(self):
- self._result = self._controller.get_task_items(
- self._folder_id, SENDER_NAME)
- self.refresh_finished.emit(self.id)
-
- def get_result(self):
- return self._result
-
-
-class TasksModel(QtGui.QStandardItemModel):
- """Tasks model which cares about refresh of tasks by folder id.
-
- Args:
- controller (AbstractWorkfilesFrontend): The control object.
- """
-
- refreshed = QtCore.Signal()
-
- def __init__(self, controller):
- super(TasksModel, self).__init__()
-
- self._controller = controller
-
- self._items_by_name = {}
- self._has_content = False
- self._is_refreshing = False
-
- self._invalid_selection_item_used = False
- self._invalid_selection_item = None
- self._empty_tasks_item_used = False
- self._empty_tasks_item = None
-
- self._last_folder_id = None
-
- self._refresh_threads = {}
- self._current_refresh_thread = None
-
- # Initial state
- self._add_invalid_selection_item()
-
- def clear(self):
- self._items_by_name = {}
- self._has_content = False
- self._remove_invalid_items()
- super(TasksModel, self).clear()
-
- def refresh(self, folder_id):
- """Refresh tasks for folder.
-
- Args:
- folder_id (Union[str, None]): Folder id.
- """
-
- self._refresh(folder_id)
-
- def get_index_by_name(self, task_name):
- """Find item by name and return its index.
-
- Returns:
- QtCore.QModelIndex: Index of item. Is invalid if task is not
- found by name.
- """
-
- item = self._items_by_name.get(task_name)
- if item is None:
- return QtCore.QModelIndex()
- return self.indexFromItem(item)
-
- def get_last_folder_id(self):
- """Get last refreshed folder id.
-
- Returns:
- Union[str, None]: Folder id.
- """
-
- return self._last_folder_id
-
- def _get_invalid_selection_item(self):
- if self._invalid_selection_item is None:
- item = QtGui.QStandardItem("Select a folder")
- item.setFlags(QtCore.Qt.NoItemFlags)
- icon = qtawesome.icon(
- "fa.times",
- color=get_disabled_entity_icon_color()
- )
- item.setData(icon, QtCore.Qt.DecorationRole)
- self._invalid_selection_item = item
- return self._invalid_selection_item
-
- def _get_empty_task_item(self):
- if self._empty_tasks_item is None:
- item = QtGui.QStandardItem("No task")
- icon = qtawesome.icon(
- "fa.exclamation-circle",
- color=get_disabled_entity_icon_color()
- )
- item.setData(icon, QtCore.Qt.DecorationRole)
- item.setFlags(QtCore.Qt.NoItemFlags)
- self._empty_tasks_item = item
- return self._empty_tasks_item
-
- def _add_invalid_item(self, item):
- self.clear()
- root_item = self.invisibleRootItem()
- root_item.appendRow(item)
-
- def _remove_invalid_item(self, item):
- root_item = self.invisibleRootItem()
- root_item.takeRow(item.row())
-
- def _remove_invalid_items(self):
- self._remove_invalid_selection_item()
- self._remove_empty_task_item()
-
- def _add_invalid_selection_item(self):
- if not self._invalid_selection_item_used:
- self._add_invalid_item(self._get_invalid_selection_item())
- self._invalid_selection_item_used = True
-
- def _remove_invalid_selection_item(self):
- if self._invalid_selection_item:
- self._remove_invalid_item(self._get_invalid_selection_item())
- self._invalid_selection_item_used = False
-
- def _add_empty_task_item(self):
- if not self._empty_tasks_item_used:
- self._add_invalid_item(self._get_empty_task_item())
- self._empty_tasks_item_used = True
-
- def _remove_empty_task_item(self):
- if self._empty_tasks_item_used:
- self._remove_invalid_item(self._get_empty_task_item())
- self._empty_tasks_item_used = False
-
- def _refresh(self, folder_id):
- self._is_refreshing = True
- self._last_folder_id = folder_id
- if not folder_id:
- self._add_invalid_selection_item()
- self._current_refresh_thread = None
- self._is_refreshing = False
- self.refreshed.emit()
- return
-
- thread = RefreshThread(self._controller, folder_id)
- self._current_refresh_thread = thread.id
- self._refresh_threads[thread.id] = thread
- thread.refresh_finished.connect(self._on_refresh_thread)
- thread.start()
-
- def _on_refresh_thread(self, thread_id):
- """Callback when refresh thread is finished.
-
- Technically can be running multiple refresh threads at the same time,
- to avoid using values from wrong thread, we check if thread id is
- current refresh thread id.
-
- Tasks are stored by name, so if a folder has same task name as
- previously selected folder it keeps the selection.
-
- Args:
- thread_id (str): Thread id.
- """
-
- thread = self._refresh_threads.pop(thread_id)
- if thread_id != self._current_refresh_thread:
- return
-
- task_items = thread.get_result()
- # Task items are refreshed
- if task_items is None:
- return
-
- # No tasks are available on folder
- if not task_items:
- self._add_empty_task_item()
- return
- self._remove_invalid_items()
-
- new_items = []
- new_names = set()
- for task_item in task_items:
- name = task_item.name
- new_names.add(name)
- item = self._items_by_name.get(name)
- if item is None:
- item = QtGui.QStandardItem()
- item.setEditable(False)
- new_items.append(item)
- self._items_by_name[name] = item
-
- # TODO cache locally
- icon = qtawesome.icon(
- task_item.icon_name,
- color=task_item.icon_color,
- )
- item.setData(task_item.label, QtCore.Qt.DisplayRole)
- item.setData(name, ITEM_NAME_ROLE)
- item.setData(task_item.id, ITEM_ID_ROLE)
- item.setData(task_item.parent_id, PARENT_ID_ROLE)
- item.setData(icon, QtCore.Qt.DecorationRole)
-
- root_item = self.invisibleRootItem()
-
- for name in set(self._items_by_name) - new_names:
- item = self._items_by_name.pop(name)
- root_item.removeRow(item.row())
-
- if new_items:
- root_item.appendRows(new_items)
-
- self._has_content = root_item.rowCount() > 0
- self._is_refreshing = False
- self.refreshed.emit()
-
- @property
- def is_refreshing(self):
- """Model is refreshing.
-
- Returns:
- bool: Model is refreshing
- """
-
- return self._is_refreshing
-
- @property
- def has_content(self):
- """Model has content.
-
- Returns:
- bools: Have at least one task.
- """
-
- return self._has_content
-
- def headerData(self, section, orientation, role):
- # Show nice labels in the header
- if (
- role == QtCore.Qt.DisplayRole
- and orientation == QtCore.Qt.Horizontal
- ):
- if section == 0:
- return "Tasks"
-
- return super(TasksModel, self).headerData(
- section, orientation, role
- )
-
-
-class TasksWidget(QtWidgets.QWidget):
- """Tasks widget.
-
- Widget that handles tasks view, model and selection.
-
- Args:
- controller (AbstractWorkfilesFrontend): Workfiles controller.
- """
-
- def __init__(self, controller, parent):
- super(TasksWidget, self).__init__(parent)
-
- tasks_view = DeselectableTreeView(self)
- tasks_view.setIndentation(0)
-
- tasks_model = TasksModel(controller)
- tasks_proxy_model = QtCore.QSortFilterProxyModel()
- tasks_proxy_model.setSourceModel(tasks_model)
-
- tasks_view.setModel(tasks_proxy_model)
-
- main_layout = QtWidgets.QHBoxLayout(self)
- main_layout.setContentsMargins(0, 0, 0, 0)
- main_layout.addWidget(tasks_view, 1)
-
- controller.register_event_callback(
- "tasks.refresh.finished",
- self._on_tasks_refresh_finished
- )
- controller.register_event_callback(
- "selection.folder.changed",
- self._folder_selection_changed
- )
- controller.register_event_callback(
- "expected_selection_changed",
- self._on_expected_selection_change
- )
-
- selection_model = tasks_view.selectionModel()
- selection_model.selectionChanged.connect(self._on_selection_change)
-
- tasks_model.refreshed.connect(self._on_tasks_model_refresh)
-
- self._controller = controller
- self._tasks_view = tasks_view
- self._tasks_model = tasks_model
- self._tasks_proxy_model = tasks_proxy_model
-
- self._selected_folder_id = None
-
- self._expected_selection_data = None
-
- def _clear(self):
- self._tasks_model.clear()
-
- def _on_tasks_refresh_finished(self, event):
- """Tasks were refreshed in controller.
-
- Ignore if refresh was triggered by tasks model, or refreshed folder is
- not the same as currently selected folder.
-
- Args:
- event (Event): Event object.
- """
-
- # Refresh only if current folder id is the same
- if (
- event["sender"] == SENDER_NAME
- or event["folder_id"] != self._selected_folder_id
- ):
- return
- self._tasks_model.refresh(self._selected_folder_id)
-
- def _folder_selection_changed(self, event):
- self._selected_folder_id = event["folder_id"]
- self._tasks_model.refresh(self._selected_folder_id)
-
- def _on_tasks_model_refresh(self):
- if not self._set_expected_selection():
- self._on_selection_change()
- self._tasks_proxy_model.sort(0)
-
- def _set_expected_selection(self):
- if self._expected_selection_data is None:
- return False
- folder_id = self._expected_selection_data["folder_id"]
- task_name = self._expected_selection_data["task_name"]
- self._expected_selection_data = None
- model_folder_id = self._tasks_model.get_last_folder_id()
- if folder_id != model_folder_id:
- return False
- if task_name is not None:
- index = self._tasks_model.get_index_by_name(task_name)
- if index.isValid():
- proxy_index = self._tasks_proxy_model.mapFromSource(index)
- self._tasks_view.setCurrentIndex(proxy_index)
- self._controller.expected_task_selected(folder_id, task_name)
- return True
-
- def _on_expected_selection_change(self, event):
- if event["task_selected"] or not event["folder_selected"]:
- return
-
- model_folder_id = self._tasks_model.get_last_folder_id()
- folder_id = event["folder_id"]
- self._expected_selection_data = {
- "task_name": event["task_name"],
- "folder_id": folder_id,
- }
-
- if folder_id != model_folder_id or self._tasks_model.is_refreshing:
- return
- self._set_expected_selection()
-
- def _get_selected_item_ids(self):
- selection_model = self._tasks_view.selectionModel()
- for index in selection_model.selectedIndexes():
- task_id = index.data(ITEM_ID_ROLE)
- task_name = index.data(ITEM_NAME_ROLE)
- parent_id = index.data(PARENT_ID_ROLE)
- if task_name is not None:
- return parent_id, task_id, task_name
- return self._selected_folder_id, None, None
-
- def _on_selection_change(self):
- # Don't trigger task change during refresh
- # - a task was deselected if that happens
- # - can cause crash triggered during tasks refreshing
- if self._tasks_model.is_refreshing:
- return
- parent_id, task_id, task_name = self._get_selected_item_ids()
- self._controller.set_selected_task(parent_id, task_id, task_name)
diff --git a/openpype/tools/ayon_workfiles/widgets/window.py b/openpype/tools/ayon_workfiles/widgets/window.py
index 6218d2dd06..eb2f2bc1c7 100644
--- a/openpype/tools/ayon_workfiles/widgets/window.py
+++ b/openpype/tools/ayon_workfiles/widgets/window.py
@@ -5,32 +5,16 @@ from openpype.tools.utils import (
PlaceholderLineEdit,
MessageOverlayObject,
)
-from openpype.tools.utils.lib import get_qta_icon_by_name_and_color
+from openpype.tools.ayon_utils.widgets import FoldersWidget, TasksWidget
from openpype.tools.ayon_workfiles.control import BaseWorkfileController
+from openpype.tools.utils import GoToCurrentButton, RefreshButton
from .side_panel import SidePanelWidget
-from .folders_widget import FoldersWidget
-from .tasks_widget import TasksWidget
from .files_widget import FilesWidget
from .utils import BaseOverlayFrame
-# TODO move to utils
-# from openpype.tools.utils.lib import (
-# get_refresh_icon, get_go_to_current_icon)
-def get_refresh_icon():
- return get_qta_icon_by_name_and_color(
- "fa.refresh", style.get_default_tools_icon_color()
- )
-
-
-def get_go_to_current_icon():
- return get_qta_icon_by_name_and_color(
- "fa.arrow-down", style.get_default_tools_icon_color()
- )
-
-
class InvalidHostOverlay(BaseOverlayFrame):
def __init__(self, parent):
super(InvalidHostOverlay, self).__init__(parent)
@@ -80,7 +64,7 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
self._default_window_flags = flags
- self._folder_widget = None
+ self._folders_widget = None
self._folder_filter_input = None
self._files_widget = None
@@ -100,7 +84,9 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
home_body_widget = QtWidgets.QWidget(home_page_widget)
col_1_widget = self._create_col_1_widget(controller, parent)
- tasks_widget = TasksWidget(controller, home_body_widget)
+ tasks_widget = TasksWidget(
+ controller, home_body_widget, handle_expected_selection=True
+ )
col_3_widget = self._create_col_3_widget(controller, home_body_widget)
side_panel = SidePanelWidget(controller, home_body_widget)
@@ -151,11 +137,11 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
self._on_open_finished
)
controller.register_event_callback(
- "controller.refresh.started",
+ "controller.reset.started",
self._on_controller_refresh_started,
)
controller.register_event_callback(
- "controller.refresh.finished",
+ "controller.reset.finished",
self._on_controller_refresh_finished,
)
@@ -188,19 +174,12 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
folder_filter_input = PlaceholderLineEdit(header_widget)
folder_filter_input.setPlaceholderText("Filter folders..")
- go_to_current_btn = QtWidgets.QPushButton(header_widget)
- go_to_current_btn.setIcon(get_go_to_current_icon())
- go_to_current_btn_sp = go_to_current_btn.sizePolicy()
- go_to_current_btn_sp.setVerticalPolicy(QtWidgets.QSizePolicy.Minimum)
- go_to_current_btn.setSizePolicy(go_to_current_btn_sp)
+ go_to_current_btn = GoToCurrentButton(header_widget)
+ refresh_btn = RefreshButton(header_widget)
- refresh_btn = QtWidgets.QPushButton(header_widget)
- refresh_btn.setIcon(get_refresh_icon())
- refresh_btn_sp = refresh_btn.sizePolicy()
- refresh_btn_sp.setVerticalPolicy(QtWidgets.QSizePolicy.Minimum)
- refresh_btn.setSizePolicy(refresh_btn_sp)
-
- folder_widget = FoldersWidget(controller, col_widget)
+ folder_widget = FoldersWidget(
+ controller, col_widget, handle_expected_selection=True
+ )
header_layout = QtWidgets.QHBoxLayout(header_widget)
header_layout.setContentsMargins(0, 0, 0, 0)
@@ -218,7 +197,7 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
refresh_btn.clicked.connect(self._on_refresh_clicked)
self._folder_filter_input = folder_filter_input
- self._folder_widget = folder_widget
+ self._folders_widget = folder_widget
return col_widget
@@ -300,7 +279,7 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
def refresh(self):
"""Trigger refresh of workfiles tool controller."""
- self._controller.refresh()
+ self._controller.reset()
def showEvent(self, event):
super(WorkfilesToolWindow, self).showEvent(event)
@@ -338,7 +317,7 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
self._side_panel.set_published_mode(published_mode)
def _on_folder_filter_change(self, text):
- self._folder_widget.set_name_filter(text)
+ self._folders_widget.set_name_filter(text)
def _on_go_to_current_clicked(self):
self._controller.go_to_current_context()
@@ -357,6 +336,10 @@ class WorkfilesToolWindow(QtWidgets.QWidget):
if not self._host_is_valid:
return
+ self._folders_widget.set_project_name(
+ self._controller.get_current_project_name()
+ )
+
def _on_save_as_finished(self, event):
if event["failed"]:
self._overlay_messages_widget.add_message(
diff --git a/openpype/tools/creator/window.py b/openpype/tools/creator/window.py
index 47f27a262a..117519e1d7 100644
--- a/openpype/tools/creator/window.py
+++ b/openpype/tools/creator/window.py
@@ -214,7 +214,7 @@ class CreatorWindow(QtWidgets.QDialog):
asset_name = self._asset_name_input.text()
# Early exit if no asset name
- if not asset_name.strip():
+ if not asset_name:
self._build_menu()
self.echo("Asset name is required ..")
self._set_valid_state(False)
diff --git a/openpype/tools/publisher/control.py b/openpype/tools/publisher/control.py
index a6264303d5..9e00d21750 100644
--- a/openpype/tools/publisher/control.py
+++ b/openpype/tools/publisher/control.py
@@ -12,10 +12,12 @@ from abc import ABCMeta, abstractmethod
import six
import pyblish.api
+from openpype import AYON_SERVER_ENABLED
from openpype.client import (
get_assets,
get_asset_by_id,
get_subsets,
+ get_asset_name_identifier,
)
from openpype.lib.events import EventSystem
from openpype.lib.attribute_definitions import (
@@ -73,6 +75,8 @@ class AssetDocsCache:
"data.visualParent": True,
"data.tasks": True
}
+ if AYON_SERVER_ENABLED:
+ projection["data.parents"] = True
def __init__(self, controller):
self._controller = controller
@@ -105,7 +109,7 @@ class AssetDocsCache:
elif "tasks" not in asset_doc["data"]:
asset_doc["data"]["tasks"] = {}
- asset_name = asset_doc["name"]
+ asset_name = get_asset_name_identifier(asset_doc)
asset_tasks = asset_doc["data"]["tasks"]
task_names_by_asset_name[asset_name] = list(asset_tasks.keys())
asset_docs_by_name[asset_name] = asset_doc
@@ -1453,7 +1457,7 @@ class BasePublisherController(AbstractPublisherController):
"""
if self._log is None:
- self._log = logging.getLogget(self.__class__.__name__)
+ self._log = logging.getLogger(self.__class__.__name__)
return self._log
@property
@@ -1881,10 +1885,19 @@ class PublisherController(BasePublisherController):
self._emit_event("plugins.refresh.finished")
def _collect_creator_items(self):
- return {
- identifier: CreatorItem.from_creator(creator)
- for identifier, creator in self._create_context.creators.items()
- }
+ # TODO add crashed initialization of create plugins to report
+ output = {}
+ for identifier, creator in self._create_context.creators.items():
+ try:
+ output[identifier] = CreatorItem.from_creator(creator)
+ except Exception:
+ self.log.error(
+ "Failed to create creator item for '%s'",
+ identifier,
+ exc_info=True
+ )
+
+ return output
def _reset_instances(self):
"""Reset create instances."""
diff --git a/openpype/tools/publisher/widgets/assets_widget.py b/openpype/tools/publisher/widgets/assets_widget.py
index c536f93c9b..32be514dd7 100644
--- a/openpype/tools/publisher/widgets/assets_widget.py
+++ b/openpype/tools/publisher/widgets/assets_widget.py
@@ -11,7 +11,8 @@ from openpype.tools.utils import (
from openpype.tools.utils.assets_widget import (
SingleSelectAssetsWidget,
ASSET_ID_ROLE,
- ASSET_NAME_ROLE
+ ASSET_NAME_ROLE,
+ ASSET_PATH_ROLE,
)
@@ -31,6 +32,15 @@ class CreateWidgetAssetsWidget(SingleSelectAssetsWidget):
self._last_filter_height = None
+ def get_selected_asset_name(self):
+ if AYON_SERVER_ENABLED:
+ selection_model = self._view.selectionModel()
+ indexes = selection_model.selectedRows()
+ for index in indexes:
+ return index.data(ASSET_PATH_ROLE)
+ return None
+ return super(CreateWidgetAssetsWidget, self).get_selected_asset_name()
+
def _check_header_height(self):
"""Catch header height changes.
@@ -100,21 +110,24 @@ class AssetsHierarchyModel(QtGui.QStandardItemModel):
self._controller = controller
self._items_by_name = {}
+ self._items_by_path = {}
self._items_by_asset_id = {}
def reset(self):
self.clear()
self._items_by_name = {}
+ self._items_by_path = {}
self._items_by_asset_id = {}
assets_by_parent_id = self._controller.get_asset_hierarchy()
items_by_name = {}
+ items_by_path = {}
items_by_asset_id = {}
_queue = collections.deque()
- _queue.append((self.invisibleRootItem(), None))
+ _queue.append((self.invisibleRootItem(), None, None))
while _queue:
- parent_item, parent_id = _queue.popleft()
+ parent_item, parent_id, parent_path = _queue.popleft()
children = assets_by_parent_id.get(parent_id)
if not children:
continue
@@ -127,6 +140,11 @@ class AssetsHierarchyModel(QtGui.QStandardItemModel):
for name in sorted(children_by_name.keys()):
child = children_by_name[name]
child_id = child["_id"]
+ if parent_path:
+ child_path = "{}/{}".format(parent_path, name)
+ else:
+ child_path = "/{}".format(name)
+
has_children = bool(assets_by_parent_id.get(child_id))
icon = get_asset_icon(child, has_children)
@@ -138,15 +156,18 @@ class AssetsHierarchyModel(QtGui.QStandardItemModel):
item.setData(icon, QtCore.Qt.DecorationRole)
item.setData(child_id, ASSET_ID_ROLE)
item.setData(name, ASSET_NAME_ROLE)
+ item.setData(child_path, ASSET_PATH_ROLE)
items_by_name[name] = item
+ items_by_path[child_path] = item
items_by_asset_id[child_id] = item
items.append(item)
- _queue.append((item, child_id))
+ _queue.append((item, child_id, child_path))
parent_item.appendRows(items)
self._items_by_name = items_by_name
+ self._items_by_path = items_by_path
self._items_by_asset_id = items_by_asset_id
def get_index_by_asset_id(self, asset_id):
@@ -156,12 +177,20 @@ class AssetsHierarchyModel(QtGui.QStandardItemModel):
return QtCore.QModelIndex()
def get_index_by_asset_name(self, asset_name):
- item = self._items_by_name.get(asset_name)
+ item = None
+ if AYON_SERVER_ENABLED:
+ item = self._items_by_path.get(asset_name)
+
+ if item is None:
+ item = self._items_by_name.get(asset_name)
+
if item is None:
return QtCore.QModelIndex()
return item.index()
def name_is_valid(self, item_name):
+ if AYON_SERVER_ENABLED and item_name in self._items_by_path:
+ return True
return item_name in self._items_by_name
@@ -296,7 +325,10 @@ class AssetsDialog(QtWidgets.QDialog):
index = self._asset_view.currentIndex()
asset_name = None
if index.isValid():
- asset_name = index.data(ASSET_NAME_ROLE)
+ if AYON_SERVER_ENABLED:
+ asset_name = index.data(ASSET_PATH_ROLE)
+ else:
+ asset_name = index.data(ASSET_NAME_ROLE)
self._selected_asset = asset_name
self.done(1)
diff --git a/openpype/tools/publisher/widgets/create_widget.py b/openpype/tools/publisher/widgets/create_widget.py
index 64fed1d70c..73dcae51a5 100644
--- a/openpype/tools/publisher/widgets/create_widget.py
+++ b/openpype/tools/publisher/widgets/create_widget.py
@@ -816,8 +816,13 @@ class CreateWidget(QtWidgets.QWidget):
# Where to define these data?
# - what data show be stored?
+ if AYON_SERVER_ENABLED:
+ asset_key = "folderPath"
+ else:
+ asset_key = "asset"
+
instance_data = {
- "asset": asset_name,
+ asset_key: asset_name,
"task": task_name,
"variant": variant,
"family": family
diff --git a/openpype/tools/publisher/widgets/overview_widget.py b/openpype/tools/publisher/widgets/overview_widget.py
index 778aa1139f..10151250f6 100644
--- a/openpype/tools/publisher/widgets/overview_widget.py
+++ b/openpype/tools/publisher/widgets/overview_widget.py
@@ -1,5 +1,7 @@
from qtpy import QtWidgets, QtCore
+from openpype import AYON_SERVER_ENABLED
+
from .border_label_widget import BorderedLabelWidget
from .card_view_widgets import InstanceCardView
@@ -35,7 +37,10 @@ class OverviewWidget(QtWidgets.QFrame):
# --- Created Subsets/Instances ---
# Common widget for creation and overview
subset_views_widget = BorderedLabelWidget(
- "Subsets to publish", subset_content_widget
+ "{} to publish".format(
+ "Products" if AYON_SERVER_ENABLED else "Subsets"
+ ),
+ subset_content_widget
)
subset_view_cards = InstanceCardView(controller, subset_views_widget)
diff --git a/openpype/tools/publisher/widgets/widgets.py b/openpype/tools/publisher/widgets/widgets.py
index 6dbeaad821..ecccc4e0c8 100644
--- a/openpype/tools/publisher/widgets/widgets.py
+++ b/openpype/tools/publisher/widgets/widgets.py
@@ -210,7 +210,9 @@ class CreateBtn(PublishIconBtn):
def __init__(self, parent=None):
icon_path = get_icon_path("create")
super(CreateBtn, self).__init__(icon_path, "Create", parent)
- self.setToolTip("Create new subset/s")
+ self.setToolTip("Create new {}/s".format(
+ "product" if AYON_SERVER_ENABLED else "subset"
+ ))
self.setLayoutDirection(QtCore.Qt.RightToLeft)
@@ -538,6 +540,7 @@ class AssetsField(BaseClickableFrame):
Does not change selected items (assets).
"""
self._name_input.setText(text)
+ self._name_input.end(False)
def set_selected_items(self, asset_names=None):
"""Set asset names for selection of instances.
@@ -655,7 +658,11 @@ class TasksCombobox(QtWidgets.QComboBox):
self._proxy_model.set_filter_empty(invalid)
if invalid:
self._set_is_valid(False)
- self.set_text("< One or more subsets require Task selected >")
+ self.set_text(
+ "< One or more {} require Task selected >".format(
+ "products" if AYON_SERVER_ENABLED else "subsets"
+ )
+ )
else:
self.set_text(None)
@@ -1181,7 +1188,10 @@ class GlobalAttrsWidget(QtWidgets.QWidget):
asset_names = []
for instance in self._current_instances:
new_variant_value = instance.get("variant")
- new_asset_name = instance.get("asset")
+ if AYON_SERVER_ENABLED:
+ new_asset_name = instance.get("folderPath")
+ else:
+ new_asset_name = instance.get("asset")
new_task_name = instance.get("task")
if variant_value is not None:
new_variant_value = variant_value
@@ -1213,7 +1223,11 @@ class GlobalAttrsWidget(QtWidgets.QWidget):
instance["variant"] = variant_value
if asset_name is not None:
- instance["asset"] = asset_name
+ if AYON_SERVER_ENABLED:
+ instance["folderPath"] = asset_name
+ else:
+ instance["asset"] = asset_name
+
instance.set_asset_invalid(False)
if task_name is not None:
@@ -1311,7 +1325,10 @@ class GlobalAttrsWidget(QtWidgets.QWidget):
variants.add(instance.get("variant") or self.unknown_value)
families.add(instance.get("family") or self.unknown_value)
- asset_name = instance.get("asset") or self.unknown_value
+ if AYON_SERVER_ENABLED:
+ asset_name = instance.get("folderPath") or self.unknown_value
+ else:
+ asset_name = instance.get("asset") or self.unknown_value
task_name = instance.get("task") or ""
asset_names.add(asset_name)
asset_task_combinations.append((asset_name, task_name))
diff --git a/openpype/tools/utils/assets_widget.py b/openpype/tools/utils/assets_widget.py
index a45d762c73..b83f4dfcaf 100644
--- a/openpype/tools/utils/assets_widget.py
+++ b/openpype/tools/utils/assets_widget.py
@@ -36,6 +36,7 @@ ASSET_ID_ROLE = QtCore.Qt.UserRole + 1
ASSET_NAME_ROLE = QtCore.Qt.UserRole + 2
ASSET_LABEL_ROLE = QtCore.Qt.UserRole + 3
ASSET_UNDERLINE_COLORS_ROLE = QtCore.Qt.UserRole + 4
+ASSET_PATH_ROLE = QtCore.Qt.UserRole + 5
class AssetsView(TreeViewSpinner, DeselectableTreeView):
diff --git a/openpype/version.py b/openpype/version.py
index b7394c203d..89067af269 100644
--- a/openpype/version.py
+++ b/openpype/version.py
@@ -1,3 +1,3 @@
# -*- coding: utf-8 -*-
"""Package declaring Pype version."""
-__version__ = "3.17.6-nightly.3"
+__version__ = "3.17.7-nightly.2"
diff --git a/pyproject.toml b/pyproject.toml
index c6f4880cdd..21ba7d1199 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,6 +1,6 @@
[tool.poetry]
name = "OpenPype"
-version = "3.17.5" # OpenPype
+version = "3.17.6" # OpenPype
description = "Open VFX and Animation pipeline with support."
authors = ["OpenPype Team "]
license = "MIT License"
diff --git a/server_addon/applications/server/applications.json b/server_addon/applications/server/applications.json
index db7f86e357..f846b04215 100644
--- a/server_addon/applications/server/applications.json
+++ b/server_addon/applications/server/applications.json
@@ -1092,6 +1092,32 @@
}
]
},
+ "substancepainter": {
+ "enabled": true,
+ "label": "Substance Painter",
+ "icon": "{}/app_icons/substancepainter.png",
+ "host_name": "substancepainter",
+ "environment": "{}",
+ "variants": [
+ {
+ "name": "8-2-0",
+ "label": "8.2",
+ "executables": {
+ "windows": [
+ "C:\\Program Files\\Adobe\\Adobe Substance 3D Painter\\Adobe Substance 3D Painter.exe"
+ ],
+ "darwin": [],
+ "linux": []
+ },
+ "arguments": {
+ "windows": [],
+ "darwin": [],
+ "linux": []
+ },
+ "environment": "{}"
+ }
+ ]
+ },
"unreal": {
"enabled": true,
"label": "Unreal Editor",
diff --git a/server_addon/applications/server/settings.py b/server_addon/applications/server/settings.py
index be9a2ea07e..981d56c30f 100644
--- a/server_addon/applications/server/settings.py
+++ b/server_addon/applications/server/settings.py
@@ -164,6 +164,8 @@ class ApplicationsSettings(BaseSettingsModel):
default_factory=AppGroupWithPython, title="Adobe After Effects")
celaction: AppGroup = Field(
default_factory=AppGroupWithPython, title="Celaction 2D")
+ substancepainter: AppGroup = Field(
+ default_factory=AppGroupWithPython, title="Substance Painter")
unreal: AppGroup = Field(
default_factory=AppGroupWithPython, title="Unreal Editor")
additional_apps: list[AdditionalAppGroup] = Field(
diff --git a/server_addon/applications/server/version.py b/server_addon/applications/server/version.py
index b3f4756216..ae7362549b 100644
--- a/server_addon/applications/server/version.py
+++ b/server_addon/applications/server/version.py
@@ -1 +1 @@
-__version__ = "0.1.2"
+__version__ = "0.1.3"
diff --git a/server_addon/create_ayon_addons.py b/server_addon/create_ayon_addons.py
index fe8d278321..fc7a673dcc 100644
--- a/server_addon/create_ayon_addons.py
+++ b/server_addon/create_ayon_addons.py
@@ -33,6 +33,20 @@ IGNORE_FILE_PATTERNS: List[Pattern] = [
}
]
+IGNORED_HOSTS = [
+ "flame",
+ "harmony",
+]
+
+IGNORED_MODULES = [
+ "ftrack",
+ "shotgrid",
+ "sync_server",
+ "example_addons",
+ "slack",
+ "kitsu",
+]
+
class ZipFileLongPaths(zipfile.ZipFile):
"""Allows longer paths in zip files.
@@ -202,16 +216,6 @@ def create_openpype_package(
str(pyproject_path),
(private_dir / pyproject_path.name)
)
-
- ignored_hosts = []
- ignored_modules = [
- "ftrack",
- "shotgrid",
- "sync_server",
- "example_addons",
- "slack",
- "kitsu",
- ]
# Subdirs that won't be added to output zip file
ignored_subpaths = [
["addons"],
@@ -219,11 +223,11 @@ def create_openpype_package(
]
ignored_subpaths.extend(
["hosts", host_name]
- for host_name in ignored_hosts
+ for host_name in IGNORED_HOSTS
)
ignored_subpaths.extend(
["modules", module_name]
- for module_name in ignored_modules
+ for module_name in IGNORED_MODULES
)
# Zip client
@@ -297,6 +301,7 @@ def main(
# Make sure output dir is created
output_dir.mkdir(parents=True, exist_ok=True)
+ ignored_addons = set(IGNORED_HOSTS) | set(IGNORED_MODULES)
for addon_dir in current_dir.iterdir():
if not addon_dir.is_dir():
continue
@@ -304,6 +309,9 @@ def main(
if addons and addon_dir.name not in addons:
continue
+ if addon_dir.name in ignored_addons:
+ continue
+
server_dir = addon_dir / "server"
if not server_dir.exists():
continue
diff --git a/server_addon/max/server/settings/publishers.py b/server_addon/max/server/settings/publishers.py
index df8412391a..b48f14a064 100644
--- a/server_addon/max/server/settings/publishers.py
+++ b/server_addon/max/server/settings/publishers.py
@@ -27,6 +27,26 @@ class ValidateAttributesModel(BaseSettingsModel):
return value
+class FamilyMappingItemModel(BaseSettingsModel):
+ product_types: list[str] = Field(
+ default_factory=list,
+ title="Product Types"
+ )
+ plugins: list[str] = Field(
+ default_factory=list,
+ title="Plugins"
+ )
+
+
+class ValidateLoadedPluginModel(BaseSettingsModel):
+ enabled: bool = Field(title="Enabled")
+ optional: bool = Field(title="Optional")
+ family_plugins_mapping: list[FamilyMappingItemModel] = Field(
+ default_factory=list,
+ title="Family Plugins Mapping"
+ )
+
+
class BasicValidateModel(BaseSettingsModel):
enabled: bool = Field(title="Enabled")
optional: bool = Field(title="Optional")
@@ -44,6 +64,10 @@ class PublishersModel(BaseSettingsModel):
title="Validate Attributes"
)
+ ValidateLoadedPlugin: ValidateLoadedPluginModel = Field(
+ default_factory=ValidateLoadedPluginModel,
+ title="Validate Loaded Plugin"
+ )
DEFAULT_PUBLISH_SETTINGS = {
"ValidateFrameRange": {
@@ -55,4 +79,9 @@ DEFAULT_PUBLISH_SETTINGS = {
"enabled": False,
"attributes": "{}"
},
+ "ValidateLoadedPlugin": {
+ "enabled": False,
+ "optional": True,
+ "family_plugins_mapping": []
+ }
}
diff --git a/server_addon/nuke/server/settings/imageio.py b/server_addon/nuke/server/settings/imageio.py
index 15ccd4e89a..19ad5ff24a 100644
--- a/server_addon/nuke/server/settings/imageio.py
+++ b/server_addon/nuke/server/settings/imageio.py
@@ -213,16 +213,16 @@ class ImageIOSettings(BaseSettingsModel):
DEFAULT_IMAGEIO_SETTINGS = {
"viewer": {
- "viewerProcess": "sRGB"
+ "viewerProcess": "sRGB (default)"
},
"baking": {
- "viewerProcess": "rec709"
+ "viewerProcess": "rec709 (default)"
},
"workfile": {
- "color_management": "Nuke",
+ "color_management": "OCIO",
"native_ocio_config": "nuke-default",
- "working_space": "linear",
- "thumbnail_space": "sRGB",
+ "working_space": "scene_linear",
+ "thumbnail_space": "sRGB (default)",
},
"nodes": {
"required_nodes": [
@@ -269,7 +269,7 @@ DEFAULT_IMAGEIO_SETTINGS = {
{
"type": "text",
"name": "colorspace",
- "text": "linear"
+ "text": "scene_linear"
},
{
"type": "boolean",
@@ -321,7 +321,7 @@ DEFAULT_IMAGEIO_SETTINGS = {
{
"type": "text",
"name": "colorspace",
- "text": "linear"
+ "text": "scene_linear"
},
{
"type": "boolean",
@@ -368,7 +368,7 @@ DEFAULT_IMAGEIO_SETTINGS = {
{
"type": "text",
"name": "colorspace",
- "text": "sRGB"
+ "text": "texture_paint"
},
{
"type": "boolean",
diff --git a/server_addon/nuke/server/version.py b/server_addon/nuke/server/version.py
index bbab0242f6..1276d0254f 100644
--- a/server_addon/nuke/server/version.py
+++ b/server_addon/nuke/server/version.py
@@ -1 +1 @@
-__version__ = "0.1.4"
+__version__ = "0.1.5"
diff --git a/server_addon/substancepainter/server/__init__.py b/server_addon/substancepainter/server/__init__.py
new file mode 100644
index 0000000000..2bf808d508
--- /dev/null
+++ b/server_addon/substancepainter/server/__init__.py
@@ -0,0 +1,17 @@
+from typing import Type
+
+from ayon_server.addons import BaseServerAddon
+
+from .version import __version__
+from .settings import SubstancePainterSettings, DEFAULT_SPAINTER_SETTINGS
+
+
+class SubstancePainterAddon(BaseServerAddon):
+ name = "substancepainter"
+ title = "Substance Painter"
+ version = __version__
+ settings_model: Type[SubstancePainterSettings] = SubstancePainterSettings
+
+ async def get_default_settings(self):
+ settings_model_cls = self.get_settings_model()
+ return settings_model_cls(**DEFAULT_SPAINTER_SETTINGS)
diff --git a/server_addon/substancepainter/server/settings/__init__.py b/server_addon/substancepainter/server/settings/__init__.py
new file mode 100644
index 0000000000..f47f064536
--- /dev/null
+++ b/server_addon/substancepainter/server/settings/__init__.py
@@ -0,0 +1,10 @@
+from .main import (
+ SubstancePainterSettings,
+ DEFAULT_SPAINTER_SETTINGS,
+)
+
+
+__all__ = (
+ "SubstancePainterSettings",
+ "DEFAULT_SPAINTER_SETTINGS",
+)
diff --git a/server_addon/substancepainter/server/settings/imageio.py b/server_addon/substancepainter/server/settings/imageio.py
new file mode 100644
index 0000000000..e301d3d865
--- /dev/null
+++ b/server_addon/substancepainter/server/settings/imageio.py
@@ -0,0 +1,61 @@
+from pydantic import Field, validator
+from ayon_server.settings import BaseSettingsModel
+from ayon_server.settings.validators import ensure_unique_names
+
+
+class ImageIOConfigModel(BaseSettingsModel):
+ override_global_config: bool = Field(
+ False,
+ title="Override global OCIO config"
+ )
+ filepath: list[str] = Field(
+ default_factory=list,
+ title="Config path"
+ )
+
+
+class ImageIOFileRuleModel(BaseSettingsModel):
+ name: str = Field("", title="Rule name")
+ pattern: str = Field("", title="Regex pattern")
+ colorspace: str = Field("", title="Colorspace name")
+ ext: str = Field("", title="File extension")
+
+
+class ImageIOFileRulesModel(BaseSettingsModel):
+ activate_host_rules: bool = Field(False)
+ rules: list[ImageIOFileRuleModel] = Field(
+ default_factory=list,
+ title="Rules"
+ )
+
+ @validator("rules")
+ def validate_unique_outputs(cls, value):
+ ensure_unique_names(value)
+ return value
+
+
+class ImageIOSettings(BaseSettingsModel):
+ activate_host_color_management: bool = Field(
+ True, title="Enable Color Management"
+ )
+ ocio_config: ImageIOConfigModel = Field(
+ default_factory=ImageIOConfigModel,
+ title="OCIO config"
+ )
+ file_rules: ImageIOFileRulesModel = Field(
+ default_factory=ImageIOFileRulesModel,
+ title="File Rules"
+ )
+
+
+DEFAULT_IMAGEIO_SETTINGS = {
+ "activate_host_color_management": True,
+ "ocio_config": {
+ "override_global_config": False,
+ "filepath": []
+ },
+ "file_rules": {
+ "activate_host_rules": False,
+ "rules": []
+ }
+}
diff --git a/server_addon/substancepainter/server/settings/main.py b/server_addon/substancepainter/server/settings/main.py
new file mode 100644
index 0000000000..f8397c3c08
--- /dev/null
+++ b/server_addon/substancepainter/server/settings/main.py
@@ -0,0 +1,26 @@
+from pydantic import Field
+from ayon_server.settings import BaseSettingsModel
+from .imageio import ImageIOSettings, DEFAULT_IMAGEIO_SETTINGS
+
+
+class ShelvesSettingsModel(BaseSettingsModel):
+ _layout = "compact"
+ name: str = Field(title="Name")
+ value: str = Field(title="Path")
+
+
+class SubstancePainterSettings(BaseSettingsModel):
+ imageio: ImageIOSettings = Field(
+ default_factory=ImageIOSettings,
+ title="Color Management (ImageIO)"
+ )
+ shelves: list[ShelvesSettingsModel] = Field(
+ default_factory=list,
+ title="Shelves"
+ )
+
+
+DEFAULT_SPAINTER_SETTINGS = {
+ "imageio": DEFAULT_IMAGEIO_SETTINGS,
+ "shelves": []
+}
diff --git a/server_addon/substancepainter/server/version.py b/server_addon/substancepainter/server/version.py
new file mode 100644
index 0000000000..3dc1f76bc6
--- /dev/null
+++ b/server_addon/substancepainter/server/version.py
@@ -0,0 +1 @@
+__version__ = "0.1.0"