Publish: register publishes without copying them

openpype/plugins/publish/collect_resources_path.py

@@ -15,7 +15,11 @@
 
 
 class CollectResourcesPath(pyblish.api.InstancePlugin):
-    """Generate directory path where the files and resources will be stored"""
+    """Generate directory path where the files and resources will be stored.
+
+    Collects folder name and file name from files, if exists, for in-situ
+    publishing.
+    """
 
     label = "Collect Resources Path"
     order = pyblish.api.CollectorOrder + 0.495
@@ -100,3 +104,19 @@ def process(self, instance):
 
         self.log.debug("publishDir: \"{}\"".format(publish_folder))
         self.log.debug("resourcesDir: \"{}\"".format(resources_folder))
+
+        # parse folder name and file name for online and source templates
+        # currentFile comes from hosts workfiles
+        # source comes from Publisher
+        current_file = instance.data.get("currentFile")
+        source = instance.data.get("source")
+        source_file = current_file or source
+        if source_file and os.path.exists(source_file):
+            self.log.debug("Parsing paths for {}".format(source_file))
+            if not instance.data.get("originalBasename"):
+                instance.data["originalBasename"] = \
+                    os.path.basename(source_file)
+
+            if not instance.data.get("originalDirname"):
+                instance.data["originalDirname"] = \
+                    os.path.dirname(source_file)

openpype/plugins/publish/integrate.py

@@ -268,6 +268,8 @@ def register(self, instance, file_transactions, filtered_repres):
         )
         instance.data["versionEntity"] = version
 
+        anatomy = instance.context.data["anatomy"]
+
         # Get existing representations (if any)
         existing_repres_by_name = {
             repre_doc["name"].lower(): repre_doc
@@ -291,6 +293,14 @@ def register(self, instance, file_transactions, filtered_repres):
                 instance)
 
             for src, dst in prepared["transfers"]:
+
+                if self._are_paths_same(src, dst):
+                    continue
+
+                if not self._is_path_in_project_roots(anatomy.all_root_paths(),
+                                                      dst):
+                    continue
+
                 # todo: add support for hardlink transfers
                 file_transactions.add(src, dst)
 
@@ -301,13 +311,20 @@ def register(self, instance, file_transactions, filtered_repres):
         # .ma representation. Those destination paths are pre-defined, etc.
         # todo: should we move or simplify this logic?
         resource_destinations = set()
-        for src, dst in instance.data.get("transfers", []):
-            file_transactions.add(src, dst, mode=FileTransaction.MODE_COPY)
-            resource_destinations.add(os.path.abspath(dst))
 
-        for src, dst in instance.data.get("hardlinks", []):
-            file_transactions.add(src, dst, mode=FileTransaction.MODE_HARDLINK)
-            resource_destinations.add(os.path.abspath(dst))
+        file_copy_modes = [
+            ("transfers", FileTransaction.MODE_COPY),
+            ("hardlinks", FileTransaction.MODE_HARDLINK)
+        ]
+        for files_type, copy_mode in zip(*file_copy_modes):  # unpack
+            for src, dst in instance.data.get(files_type, []):
+                if self._are_paths_same(src, dst):
+                    continue
+                if not self._is_path_in_project_roots(anatomy.all_root_paths(),
+                                                      dst):
+                    continue
+                file_transactions.add(src, dst, mode=copy_mode)
+                resource_destinations.add(os.path.abspath(dst))
 
         # Bulk write to the database
         # We write the subset and version to the database before the File
@@ -340,7 +357,6 @@ def register(self, instance, file_transactions, filtered_repres):
         # Compute the resource file infos once (files belonging to the
         # version instance instead of an individual representation) so
         # we can re-use those file infos per representation
-        anatomy = instance.context.data["anatomy"]
         resource_file_infos = self.get_files_info(resource_destinations,
                                                   sites=sites,
                                                   anatomy=anatomy)
@@ -527,15 +543,33 @@ def prepare_representation(self, repre,
         template_data["representation"] = repre["name"]
         template_data["ext"] = repre["ext"]
 
+        stagingdir = repre.get("stagingDir")
+        if not stagingdir:
+            # Fall back to instance staging dir if not explicitly
+            # set for representation in the instance
+            self.log.debug((
+                "Representation uses instance staging dir: {}"
+            ).format(instance_stagingdir))
+            stagingdir = instance_stagingdir
+
+        if not stagingdir:
+            raise KnownPublishError(
+                "No staging directory set for representation: {}".format(repre)
+            )
+
         # optionals
         # retrieve additional anatomy data from representation if exists
+        if not instance.data.get("originalDirname"):
+            instance.data["originalDirname"] = stagingdir
+
         for key, anatomy_key in {
             # Representation Key: Anatomy data key
             "resolutionWidth": "resolution_width",
             "resolutionHeight": "resolution_height",
             "fps": "fps",
             "outputName": "output",
-            "originalBasename": "originalBasename"
+            "originalBasename": "originalBasename",
+            "originalDirname": "originalDirname"
         }.items():
             # Allow to take value from representation
             # if not found also consider instance.data
@@ -546,20 +580,6 @@ def prepare_representation(self, repre,
             if value is not None:
                 template_data[anatomy_key] = value
 
-        stagingdir = repre.get("stagingDir")
-        if not stagingdir:
-            # Fall back to instance staging dir if not explicitly
-            # set for representation in the instance
-            self.log.debug((
-                "Representation uses instance staging dir: {}"
-            ).format(instance_stagingdir))
-            stagingdir = instance_stagingdir
-
-        if not stagingdir:
-            raise KnownPublishError(
-                "No staging directory set for representation: {}".format(repre)
-            )
-
         self.log.debug("Anatomy template name: {}".format(template_name))
         anatomy = instance.context.data["anatomy"]
         publish_template_category = anatomy.templates[template_name]
@@ -585,6 +605,7 @@ def prepare_representation(self, repre,
                 ))
 
             src_collection = src_collections[0]
+            template_data["originalBasename"] = src_collection.head[:-1]
             destination_indexes = list(src_collection.indexes)
             # Use last frame for minimum padding
             #   - that should cover both 'udim' and 'frame' minimum padding
@@ -669,7 +690,8 @@ def prepare_representation(self, repre,
                 raise KnownPublishError(
                     "This is a bug. Representation file name is full path"
                 )
-
+            if not template_data.get("originalBasename"):
+                template_data["originalBasename"] = fname
             # Manage anatomy template data
             template_data.pop("frame", None)
             if is_udim:
@@ -888,3 +910,34 @@ def prepare_file_info(self, path, anatomy, sites):
             "hash": source_hash(path),
             "sites": sites
         }
+
+    def _is_path_in_project_roots(self, roots, file_path):
+        """Checks if 'file_path' starts with any of the roots.
+
+        Used to check that published path belongs to project, eg. we are not
+        trying to publish to local only folder.
+        Args:
+            roots (list of RootItem): {ROOT_NAME: ROOT_PATH}
+            file_path (str)
+        Returns:
+            (bool)
+        """
+        file_path = str(file_path).replace("\\", "/").lower()
+        for root_item in roots:
+            if file_path.startswith(root_item.lower()):
+                return True
+        self.log.warning(
+            "Destination '{}' is not in project folder. Skipping"
+            .format(file_path))
+        return False
+
+    def _are_paths_same(self, src, dst):
+        src = str(src).replace("\\", "/").lower()
+        dst = str(dst).replace("\\", "/").lower()
+
+        same = src == dst
+        if same:
+            self.log.info(
+                "Source '{}' same as destination '{}'. Skipping."
+                .format(src, dst))
+        return same

openpype/settings/defaults/project_anatomy/templates.json

@@ -53,11 +53,17 @@
             "file": "{originalBasename}<.{@frame}><_{udim}>.{ext}",
             "path": "{@folder}/{@file}"
         },
+        "source": {
+            "folder": "{originalBasename}<.{@frame}><_{udim}>.{ext}",
+            "file": "{originalDirname}",
+            "path": "{@folder}/{@file}"
+        },
         "__dynamic_keys_labels__": {
             "maya2unreal": "Maya to Unreal",
             "simpleUnrealTextureHero": "Simple Unreal Texture - Hero",
             "simpleUnrealTexture": "Simple Unreal Texture",
-            "online": "online"
+            "online": "online",
+            "source": "source"
         }
     }
 }