Merge branch 'develop' of github.com:pypeclub/OpenPype into enhancement/OP-2787_Maya-ABC-farm-publishing

openpype/hosts/hiero/api/otio/hiero_export.py

@@ -151,7 +151,7 @@ def create_otio_reference(clip):
     padding = media_source.filenamePadding()
     file_head = media_source.filenameHead()
     is_sequence = not media_source.singleFile()
-    frame_duration = media_source.duration()
+    frame_duration = media_source.duration() - 1
     fps = utils.get_rate(clip) or self.project_fps
     extension = os.path.splitext(path)[-1]
 

openpype/hosts/hiero/plugins/publish/precollect_instances.py

@@ -296,6 +296,8 @@ class PrecollectInstances(pyblish.api.ContextPlugin):
                 continue
             if otio_clip.name not in track_item.name():
                 continue
+            self.log.debug("__ parent_range: {}".format(parent_range))
+            self.log.debug("__ timeline_range: {}".format(timeline_range))
             if openpype.lib.is_overlapping_otio_ranges(
                     parent_range, timeline_range, strict=True):
 

openpype/hosts/maya/plugins/load/actions.py

@@ -1,7 +1,7 @@
 """A module containing generic loader actions that will display in the Loader.
 
 """
-
+import qargparse
 from openpype.pipeline import load
 from openpype.hosts.maya.api.lib import (
     maintained_selection,
@@ -98,6 +98,15 @@ class ImportMayaLoader(load.LoaderPlugin):
     icon = "arrow-circle-down"
     color = "#775555"
 
+    options = [
+        qargparse.Boolean(
+            "clean_import",
+            label="Clean import",
+            default=False,
+            help="Should all occurences of cbId be purged?"
+        )
+    ]
+
     def load(self, context, name=None, namespace=None, data=None):
         import maya.cmds as cmds
 
@@ -114,13 +123,22 @@ class ImportMayaLoader(load.LoaderPlugin):
         )
 
         with maintained_selection():
-            cmds.file(self.fname,
-                      i=True,
-                      preserveReferences=True,
-                      namespace=namespace,
-                      returnNewNodes=True,
-                      groupReference=True,
-                      groupName="{}:{}".format(namespace, name))
+            nodes = cmds.file(self.fname,
+                              i=True,
+                              preserveReferences=True,
+                              namespace=namespace,
+                              returnNewNodes=True,
+                              groupReference=True,
+                              groupName="{}:{}".format(namespace, name))
+
+            if data.get("clean_import", False):
+                remove_attributes = ["cbId"]
+                for node in nodes:
+                    for attr in remove_attributes:
+                        if cmds.attributeQuery(attr, node=node, exists=True):
+                            full_attr = "{}.{}".format(node, attr)
+                            print("Removing {}".format(full_attr))
+                            cmds.deleteAttr(full_attr)
 
         # We do not containerize imported content, it remains unmanaged
         return

openpype/hosts/maya/plugins/load/load_image_plane.py

@@ -83,7 +83,7 @@ class ImagePlaneLoader(load.LoaderPlugin):
 
     families = ["image", "plate", "render"]
     label = "Load imagePlane"
-    representations = ["mov", "exr", "preview", "png"]
+    representations = ["mov", "exr", "preview", "png", "jpg"]
     icon = "image"
     color = "orange"
 

openpype/hosts/standalonepublisher/plugins/publish/extract_thumbnail.py

@@ -5,6 +5,7 @@ import openpype.api
 from openpype.lib import (
     get_ffmpeg_tool_path,
     get_ffprobe_streams,
+    path_to_subprocess_arg,
 )
 
 
@@ -37,82 +38,69 @@ class ExtractThumbnailSP(pyblish.api.InstancePlugin):
         if not thumbnail_repre:
             return
 
+        thumbnail_repre.pop("thumbnail")
         files = thumbnail_repre.get("files")
         if not files:
             return
 
         if isinstance(files, list):
-            files_len = len(files)
-            file = str(files[0])
+            first_filename = str(files[0])
         else:
-            files_len = 1
-            file = files
+            first_filename = files
 
         staging_dir = None
-        is_jpeg = False
-        if file.endswith(".jpeg") or file.endswith(".jpg"):
-            is_jpeg = True
 
-        if is_jpeg and files_len == 1:
-            # skip if already is single jpeg file
-            return
+        # Convert to jpeg if not yet
+        full_input_path = os.path.join(
+            thumbnail_repre["stagingDir"], first_filename
+        )
+        self.log.info("input {}".format(full_input_path))
+        with tempfile.NamedTemporaryFile(suffix=".jpg") as tmp:
+            full_thumbnail_path = tmp.name
 
-        elif is_jpeg:
-            # use first frame as thumbnail if is sequence of jpegs
-            full_thumbnail_path = os.path.join(
-                thumbnail_repre["stagingDir"], file
-            )
-            self.log.info(
-                "For thumbnail is used file: {}".format(full_thumbnail_path)
-            )
+        self.log.info("output {}".format(full_thumbnail_path))
 
-        else:
-            # Convert to jpeg if not yet
-            full_input_path = os.path.join(thumbnail_repre["stagingDir"], file)
-            self.log.info("input {}".format(full_input_path))
+        instance.context.data["cleanupFullPaths"].append(full_thumbnail_path)
 
-            full_thumbnail_path = tempfile.mkstemp(suffix=".jpg")[1]
-            self.log.info("output {}".format(full_thumbnail_path))
+        ffmpeg_path = get_ffmpeg_tool_path("ffmpeg")
 
-            ffmpeg_path = get_ffmpeg_tool_path("ffmpeg")
+        ffmpeg_args = self.ffmpeg_args or {}
 
-            ffmpeg_args = self.ffmpeg_args or {}
+        jpeg_items = [
+            path_to_subprocess_arg(ffmpeg_path),
+            # override file if already exists
+            "-y"
+        ]
 
-            jpeg_items = [
-                "\"{}\"".format(ffmpeg_path),
-                # override file if already exists
-                "-y"
-            ]
-
-            # add input filters from peresets
-            jpeg_items.extend(ffmpeg_args.get("input") or [])
-            # input file
-            jpeg_items.append("-i \"{}\"".format(full_input_path))
+        # add input filters from peresets
+        jpeg_items.extend(ffmpeg_args.get("input") or [])
+        # input file
+        jpeg_items.extend([
+            "-i", path_to_subprocess_arg(full_input_path),
             # extract only single file
-            jpeg_items.append("-frames:v 1")
+            "-frames:v", "1",
             # Add black background for transparent images
-            jpeg_items.append((
-                "-filter_complex"
-                " \"color=black,format=rgb24[c]"
+            "-filter_complex", (
+                "\"color=black,format=rgb24[c]"
                 ";[c][0]scale2ref[c][i]"
                 ";[c][i]overlay=format=auto:shortest=1,setsar=1\""
-            ))
+            ),
+        ])
 
-            jpeg_items.extend(ffmpeg_args.get("output") or [])
+        jpeg_items.extend(ffmpeg_args.get("output") or [])
 
-            # output file
-            jpeg_items.append("\"{}\"".format(full_thumbnail_path))
+        # output file
+        jpeg_items.append(path_to_subprocess_arg(full_thumbnail_path))
 
-            subprocess_jpeg = " ".join(jpeg_items)
+        subprocess_jpeg = " ".join(jpeg_items)
 
-            # run subprocess
-            self.log.debug("Executing: {}".format(subprocess_jpeg))
-            openpype.api.run_subprocess(
-                subprocess_jpeg, shell=True, logger=self.log
-            )
+        # run subprocess
+        self.log.debug("Executing: {}".format(subprocess_jpeg))
+        openpype.api.run_subprocess(
+            subprocess_jpeg, shell=True, logger=self.log
+        )
 
         # remove thumbnail key from origin repre
-        thumbnail_repre.pop("thumbnail")
         streams = get_ffprobe_streams(full_thumbnail_path)
         width = height = None
         for stream in streams:
@@ -121,8 +109,7 @@ class ExtractThumbnailSP(pyblish.api.InstancePlugin):
                 height = stream["height"]
                 break
 
-        filename = os.path.basename(full_thumbnail_path)
-        staging_dir = staging_dir or os.path.dirname(full_thumbnail_path)
+        staging_dir, filename = os.path.split(full_thumbnail_path)
 
         # create new thumbnail representation
         representation = {
@@ -130,15 +117,11 @@ class ExtractThumbnailSP(pyblish.api.InstancePlugin):
             'ext': 'jpg',
             'files': filename,
             "stagingDir": staging_dir,
-            "tags": ["thumbnail"],
+            "tags": ["thumbnail", "delete"],
         }
         if width and height:
             representation["width"] = width
             representation["height"] = height
 
-        # # add Delete tag when temp file was rendered
-        if not is_jpeg:
-            representation["tags"].append("delete")
-
         self.log.info(f"New representation {representation}")
         instance.data["representations"].append(representation)

openpype/lib/editorial.py

@@ -17,7 +17,7 @@ def otio_range_to_frame_range(otio_range):
     start = _ot.to_frames(
         otio_range.start_time, otio_range.start_time.rate)
     end = start + _ot.to_frames(
-        otio_range.duration, otio_range.duration.rate) - 1
+        otio_range.duration, otio_range.duration.rate)
     return start, end
 
 
@@ -254,7 +254,7 @@ def get_media_range_with_retimes(otio_clip, handle_start, handle_end):
         media_in + source_in + offset_in)
     media_out_trimmed = (
         media_in + source_in + (
-            ((source_range.duration.value - 1) * abs(
+            (source_range.duration.value * abs(
                 time_scalar)) + offset_out))
 
     # calculate available handles

openpype/modules/deadline/plugins/publish/submit_publish_job.py

@@ -466,7 +466,7 @@ class ProcessSubmittedJobOnFarm(pyblish.api.InstancePlugin):
             if instance_data.get("multipartExr"):
                 preview = True
 
-            new_instance = copy(instance_data)
+            new_instance = deepcopy(instance_data)
             new_instance["subset"] = subset_name
             new_instance["subsetGroup"] = group_name
             if preview:

openpype/modules/ftrack/event_handlers_server/action_push_frame_values_to_task.py

@@ -356,7 +356,7 @@ class PushHierValuesToNonHier(ServerAction):
                 values_per_entity_id[entity_id][key] = None
 
         values = query_custom_attributes(
-            session, all_ids_with_parents, hier_attr_ids, True
+            session, hier_attr_ids, all_ids_with_parents, True
         )
         for item in values:
             entity_id = item["entity_id"]

openpype/pipeline/context_tools.py

@@ -116,10 +116,14 @@ def install_openpype_plugins(project_name=None, host_name=None):
     pyblish.api.register_discovery_filter(filter_pyblish_plugins)
     register_loader_plugin_path(LOAD_PATH)
 
+    modules_manager = ModulesManager()
+    publish_plugin_dirs = modules_manager.collect_plugin_paths()["publish"]
+    for path in publish_plugin_dirs:
+        pyblish.api.register_plugin_path(path)
+
     if host_name is None:
         host_name = os.environ.get("AVALON_APP")
 
-    modules_manager = ModulesManager()
     creator_paths = modules_manager.collect_creator_plugin_paths(host_name)
     for creator_path in creator_paths:
         register_creator_plugin_path(creator_path)

openpype/tools/project_manager/project_manager/model.py

@@ -264,6 +264,8 @@ class HierarchyModel(QtCore.QAbstractItemModel):
         if not project_doc:
             return
 
+        self.blockSignals(True)
+
         # Create project item
         project_item = ProjectItem(project_doc)
         self.add_item(project_item)
@@ -377,6 +379,8 @@ class HierarchyModel(QtCore.QAbstractItemModel):
 
             self.add_items(task_items, asset_item)
 
+        self.blockSignals(False)
+
         # Emit that project was successfully changed
         self.project_changed.emit()
 

openpype/tools/project_manager/project_manager/view.py

@@ -195,13 +195,13 @@ class HierarchyView(QtWidgets.QTreeView):
         for idx, width in widths_by_idx.items():
             self.setColumnWidth(idx, width)
 
-    def set_project(self, project_name):
+    def set_project(self, project_name, force=False):
         # Trigger helpers first
         self._project_doc_cache.set_project(project_name)
         self._tools_cache.refresh()
 
         # Trigger update of model after all data for delegates are filled
-        self._source_model.set_project(project_name)
+        self._source_model.set_project(project_name, force)
 
     def _on_project_reset(self):
         self.header_init()

openpype/tools/project_manager/project_manager/window.py

@@ -191,7 +191,7 @@ class ProjectManagerWindow(QtWidgets.QWidget):
         self._add_task_btn.setEnabled(project_name is not None)
         self._save_btn.setEnabled(project_name is not None)
         self._project_proxy_model.set_filter_default(project_name is not None)
-        self.hierarchy_view.set_project(project_name)
+        self.hierarchy_view.set_project(project_name, True)
 
     def _current_project(self):
         row = self._project_combobox.currentIndex()

openpype/tools/standalonepublish/widgets/widget_components.py

@@ -202,6 +202,7 @@ def cli_publish(data, publish_paths, gui=True):
     if os.path.exists(json_data_path):
         with open(json_data_path, "r") as f:
             result = json.load(f)
+        os.remove(json_data_path)
 
     log.info(f"Publish result: {result}")
 

openpype/version.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 """Package declaring Pype version."""
-__version__ = "3.10.0-nightly.2"
+__version__ = "3.10.0-nightly.3"