Merge remote-tracking branch 'origin/develop' into feature/1585-maya-support-for-frame-steps-and-frame-lists

openpype/hooks/pre_mac_launch.py

@@ -0,0 +1,34 @@
+import os
+from openpype.lib import PreLaunchHook
+
+
+class LaunchWithTerminal(PreLaunchHook):
+    """Mac specific pre arguments for application.
+
+    Mac applications should be launched using "open" argument which is internal
+    callbacks to open executable. We also add argument "-a" to tell it's
+    application open. This is used only for executables ending with ".app". It
+    is expected that these executables lead to app packages.
+    """
+    order = 1000
+
+    platforms = ["darwin"]
+
+    def execute(self):
+        executable = str(self.launch_context.executable)
+        # Skip executables not ending with ".app" or that are not folder
+        if not executable.endswith(".app") or not os.path.isdir(executable):
+            return
+
+        # Check if first argument match executable path
+        # - Few applications are not executed directly but through OpenPype
+        #   process (Photoshop, AfterEffects, Harmony, ...). These should not
+        #   use `open`.
+        if self.launch_context.launch_args[0] != executable:
+            return
+
+        # Tell `open` to pass arguments if there are any
+        if len(self.launch_context.launch_args) > 1:
+            self.launch_context.launch_args.insert(1, "--args")
+        # Prepend open arguments
+        self.launch_context.launch_args.insert(0, ["open", "-a"])

openpype/hosts/tvpaint/api/__init__.py

@@ -19,6 +19,10 @@ CREATE_PATH = os.path.join(PLUGINS_DIR, "create")
 
 
 def on_instance_toggle(instance, old_value, new_value):
+    # Review may not have real instance in wokrfile metadata
+    if not instance.data.get("uuid"):
+        return
+
     instance_id = instance.data["uuid"]
     found_idx = None
     current_instances = pipeline.list_instances()

openpype/hosts/tvpaint/plugins/create/create_review.py

@@ -1,19 +0,0 @@
-from avalon.tvpaint import pipeline
-from openpype.hosts.tvpaint.api import plugin
-
-
-class CreateReview(plugin.Creator):
-    """Review for global review of all layers."""
-    name = "review"
-    label = "Review"
-    family = "review"
-    icon = "cube"
-    defaults = ["Main"]
-
-    def process(self):
-        instances = pipeline.list_instances()
-        for instance in instances:
-            if instance["family"] == self.family:
-                self.log.info("Review family is already Created.")
-                return
-        super(CreateReview, self).process()

openpype/hosts/tvpaint/plugins/publish/collect_instances.py

@@ -17,6 +17,20 @@ class CollectInstances(pyblish.api.ContextPlugin):
             json.dumps(workfile_instances, indent=4)
         ))
 
+        # Backwards compatibility for workfiles that already have review
+        #   instance in metadata.
+        review_instance_exist = False
+        for instance_data in workfile_instances:
+            if instance_data["family"] == "review":
+                review_instance_exist = True
+                break
+
+        # Fake review instance if review was not found in metadata families
+        if not review_instance_exist:
+            workfile_instances.append(
+                self._create_review_instance_data(context)
+            )
+
         for instance_data in workfile_instances:
             instance_data["fps"] = context.data["sceneFps"]
 
@@ -90,6 +104,16 @@ class CollectInstances(pyblish.api.ContextPlugin):
                 instance, json.dumps(instance.data, indent=4)
             ))
 
+    def _create_review_instance_data(self, context):
+        """Fake review instance data."""
+
+        return {
+            "family": "review",
+            "asset": context.data["workfile_context"]["asset"],
+            # Dummy subset name
+            "subset": "reviewMain"
+        }
+
     def create_render_layer_instance(self, context, instance_data):
         name = instance_data["name"]
         # Change label

openpype/lib/applications.py

@@ -440,7 +440,20 @@ class EnvironmentTool:
 
 
 class ApplicationExecutable:
+    """Representation of executable loaded from settings."""
+
     def __init__(self, executable):
+        # On MacOS check if exists path to executable when ends with `.app`
+        # - it is common that path will lead to "/Applications/Blender" but
+        #   real path is "/Applications/Blender.app"
+        if (
+            platform.system().lower() == "darwin"
+            and not os.path.exists(executable)
+        ):
+            _executable = executable + ".app"
+            if os.path.exists(_executable):
+                executable = _executable
+
         self.executable_path = executable
 
     def __str__(self):
@@ -1177,17 +1190,23 @@ def prepare_context_environments(data):
 
     try:
         workdir = get_workdir_with_workdir_data(workdir_data, anatomy)
-        if not os.path.exists(workdir):
-            log.debug(
-                "Creating workdir folder: \"{}\"".format(workdir)
-            )
-            os.makedirs(workdir)
 
     except Exception as exc:
         raise ApplicationLaunchFailed(
             "Error in anatomy.format: {}".format(str(exc))
         )
 
+    if not os.path.exists(workdir):
+        log.debug(
+            "Creating workdir folder: \"{}\"".format(workdir)
+        )
+        try:
+            os.makedirs(workdir)
+        except Exception as exc:
+            raise ApplicationLaunchFailed(
+                "Couldn't create workdir because: {}".format(str(exc))
+            )
+
     context_env = {
         "AVALON_PROJECT": project_doc["name"],
         "AVALON_ASSET": asset_doc["name"],

openpype/lib/delivery.py

@@ -0,0 +1,303 @@
+"""Functions useful for delivery action or loader"""
+import os
+import shutil
+import clique
+import collections
+
+def collect_frames(files):
+    """
+        Returns dict of source path and its frame, if from sequence
+
+        Uses clique as most precise solution
+
+        Args:
+            files(list): list of source paths
+        Returns:
+            (dict): {'/asset/subset_v001.0001.png': '0001', ....}
+    """
+    collections, remainder = clique.assemble(files)
+
+    sources_and_frames = {}
+    if collections:
+        for collection in collections:
+            src_head = collection.head
+            src_tail = collection.tail
+
+            for index in collection.indexes:
+                src_frame = collection.format("{padding}") % index
+                src_file_name = "{}{}{}".format(src_head, src_frame,
+                                                src_tail)
+                sources_and_frames[src_file_name] = src_frame
+    else:
+        sources_and_frames[remainder.pop()] = None
+
+    return sources_and_frames
+
+
+def sizeof_fmt(num, suffix='B'):
+    """Returns formatted string with size in appropriate unit"""
+    for unit in ['', 'Ki', 'Mi', 'Gi', 'Ti', 'Pi', 'Ei', 'Zi']:
+        if abs(num) < 1024.0:
+            return "%3.1f%s%s" % (num, unit, suffix)
+        num /= 1024.0
+    return "%.1f%s%s" % (num, 'Yi', suffix)
+
+
+def path_from_represenation(representation, anatomy):
+    from avalon import pipeline  # safer importing
+
+    try:
+        template = representation["data"]["template"]
+
+    except KeyError:
+        return None
+
+    try:
+        context = representation["context"]
+        context["root"] = anatomy.roots
+        path = pipeline.format_template_with_optional_keys(
+            context, template
+        )
+
+    except KeyError:
+        # Template references unavailable data
+        return None
+
+    return os.path.normpath(path)
+
+
+def copy_file(src_path, dst_path):
+    """Hardlink file if possible(to save space), copy if not"""
+    from avalon.vendor import filelink  # safer importing
+
+    if os.path.exists(dst_path):
+        return
+    try:
+        filelink.create(
+            src_path,
+            dst_path,
+            filelink.HARDLINK
+        )
+    except OSError:
+        shutil.copyfile(src_path, dst_path)
+
+
+def get_format_dict(anatomy, location_path):
+    """Returns replaced root values from user provider value.
+
+        Args:
+            anatomy (Anatomy)
+            location_path (str): user provided value
+        Returns:
+            (dict): prepared for formatting of a template
+    """
+    format_dict = {}
+    if location_path:
+        location_path = location_path.replace("\\", "/")
+        root_names = anatomy.root_names_from_templates(
+            anatomy.templates["delivery"]
+        )
+        if root_names is None:
+            format_dict["root"] = location_path
+        else:
+            format_dict["root"] = {}
+            for name in root_names:
+                format_dict["root"][name] = location_path
+    return format_dict
+
+
+def check_destination_path(repre_id,
+                           anatomy, anatomy_data,
+                           datetime_data, template_name):
+    """ Try to create destination path based on 'template_name'.
+
+        In the case that path cannot be filled, template contains unmatched
+        keys, provide error message to filter out repre later.
+
+        Args:
+            anatomy (Anatomy)
+            anatomy_data (dict): context to fill anatomy
+            datetime_data (dict): values with actual date
+            template_name (str): to pick correct delivery template
+        Returns:
+            (collections.defauldict): {"TYPE_OF_ERROR":"ERROR_DETAIL"}
+    """
+    anatomy_data.update(datetime_data)
+    anatomy_filled = anatomy.format_all(anatomy_data)
+    dest_path = anatomy_filled["delivery"][template_name]
+    report_items = collections.defaultdict(list)
+    sub_msg = None
+    if not dest_path.solved:
+        msg = (
+            "Missing keys in Representation's context"
+            " for anatomy template \"{}\"."
+        ).format(template_name)
+
+        if dest_path.missing_keys:
+            keys = ", ".join(dest_path.missing_keys)
+            sub_msg = (
+                "Representation: {}<br>- Missing keys: \"{}\"<br>"
+            ).format(repre_id, keys)
+
+        if dest_path.invalid_types:
+            items = []
+            for key, value in dest_path.invalid_types.items():
+                items.append("\"{}\" {}".format(key, str(value)))
+
+            keys = ", ".join(items)
+            sub_msg = (
+                "Representation: {}<br>"
+                "- Invalid value DataType: \"{}\"<br>"
+            ).format(repre_id, keys)
+
+        report_items[msg].append(sub_msg)
+
+    return report_items
+
+
+def process_single_file(
+    src_path, repre, anatomy, template_name, anatomy_data, format_dict,
+    report_items, log
+):
+    """Copy single file to calculated path based on template
+
+        Args:
+            src_path(str): path of source representation file
+            _repre (dict): full repre, used only in process_sequence, here only
+                as to share same signature
+            anatomy (Anatomy)
+            template_name (string): user selected delivery template name
+            anatomy_data (dict): data from repre to fill anatomy with
+            format_dict (dict): root dictionary with names and values
+            report_items (collections.defaultdict): to return error messages
+            log (Logger): for log printing
+        Returns:
+            (collections.defaultdict , int)
+    """
+    if not os.path.exists(src_path):
+        msg = "{} doesn't exist for {}".format(src_path,
+                                               repre["_id"])
+        report_items["Source file was not found"].append(msg)
+        return report_items, 0
+
+    anatomy_filled = anatomy.format(anatomy_data)
+    if format_dict:
+        template_result = anatomy_filled["delivery"][template_name]
+        delivery_path = template_result.rootless.format(**format_dict)
+    else:
+        delivery_path = anatomy_filled["delivery"][template_name]
+
+    # context.representation could be .psd
+    delivery_path = delivery_path.replace("..", ".")
+
+    delivery_folder = os.path.dirname(delivery_path)
+    if not os.path.exists(delivery_folder):
+        os.makedirs(delivery_folder)
+
+    log.debug("Copying single: {} -> {}".format(src_path, delivery_path))
+    copy_file(src_path, delivery_path)
+
+    return report_items, 1
+
+
+def process_sequence(
+    src_path, repre, anatomy, template_name, anatomy_data, format_dict,
+    report_items, log
+):
+    """ For Pype2(mainly - works in 3 too) where representation might not
+        contain files.
+
+        Uses listing physical files (not 'files' on repre as a)might not be
+         present, b)might not be reliable for representation and copying them.
+
+         TODO Should be refactored when files are sufficient to drive all
+         representations.
+
+        Args:
+            src_path(str): path of source representation file
+            repre (dict): full representation
+            anatomy (Anatomy)
+            template_name (string): user selected delivery template name
+            anatomy_data (dict): data from repre to fill anatomy with
+            format_dict (dict): root dictionary with names and values
+            report_items (collections.defaultdict): to return error messages
+            log (Logger): for log printing
+        Returns:
+            (collections.defaultdict , int)
+    """
+    if not os.path.exists(src_path):
+        msg = "{} doesn't exist for {}".format(src_path,
+                                               repre["_id"])
+        report_items["Source file was not found"].append(msg)
+        return report_items, 0
+
+    dir_path, file_name = os.path.split(str(src_path))
+
+    context = repre["context"]
+    ext = context.get("ext", context.get("representation"))
+
+    if not ext:
+        msg = "Source extension not found, cannot find collection"
+        report_items[msg].append(src_path)
+        log.warning("{} <{}>".format(msg, context))
+        return report_items, 0
+
+    ext = "." + ext
+    # context.representation could be .psd
+    ext = ext.replace("..", ".")
+
+    src_collections, remainder = clique.assemble(os.listdir(dir_path))
+    src_collection = None
+    for col in src_collections:
+        if col.tail != ext:
+            continue
+
+        src_collection = col
+        break
+
+    if src_collection is None:
+        msg = "Source collection of files was not found"
+        report_items[msg].append(src_path)
+        log.warning("{} <{}>".format(msg, src_path))
+        return report_items, 0
+
+    frame_indicator = "@####@"
+
+    anatomy_data["frame"] = frame_indicator
+    anatomy_filled = anatomy.format(anatomy_data)
+
+    if format_dict:
+        template_result = anatomy_filled["delivery"][template_name]
+        delivery_path = template_result.rootless.format(**format_dict)
+    else:
+        delivery_path = anatomy_filled["delivery"][template_name]
+
+    delivery_folder = os.path.dirname(delivery_path)
+    dst_head, dst_tail = delivery_path.split(frame_indicator)
+    dst_padding = src_collection.padding
+    dst_collection = clique.Collection(
+        head=dst_head,
+        tail=dst_tail,
+        padding=dst_padding
+    )
+
+    if not os.path.exists(delivery_folder):
+        os.makedirs(delivery_folder)
+
+    src_head = src_collection.head
+    src_tail = src_collection.tail
+    uploaded = 0
+    for index in src_collection.indexes:
+        src_padding = src_collection.format("{padding}") % index
+        src_file_name = "{}{}{}".format(src_head, src_padding, src_tail)
+        src = os.path.normpath(
+            os.path.join(dir_path, src_file_name)
+        )
+
+        dst_padding = dst_collection.format("{padding}") % index
+        dst = "{}{}{}".format(dst_head, dst_padding, dst_tail)
+        log.debug("Copying single: {} -> {}".format(src, dst))
+        copy_file(src, dst)
+        uploaded += 1
+
+    return report_items, uploaded

openpype/modules/ftrack/event_handlers_server/event_sync_to_avalon.py

@@ -1101,9 +1101,6 @@ class SyncToAvalonEvent(BaseEvent):
         # Parents, Hierarchy
         ent_path_items = [ent["name"] for ent in ftrack_ent["link"]]
         parents = ent_path_items[1:len(ent_path_items)-1:]
-        hierarchy = ""
-        if len(parents) > 0:
-            hierarchy = os.path.sep.join(parents)
 
         # TODO logging
         self.log.debug(
@@ -1132,7 +1129,6 @@ class SyncToAvalonEvent(BaseEvent):
                 "ftrackId": ftrack_ent["id"],
                 "entityType": ftrack_ent.entity_type,
                 "parents": parents,
-                "hierarchy": hierarchy,
                 "tasks": {},
                 "visualParent": vis_par
             }
@@ -1975,14 +1971,9 @@ class SyncToAvalonEvent(BaseEvent):
             if cur_par == parents:
                 continue
 
-            hierarchy = ""
-            if len(parents) > 0:
-                hierarchy = os.path.sep.join(parents)
-
             if "data" not in self.updates[mongo_id]:
                 self.updates[mongo_id]["data"] = {}
             self.updates[mongo_id]["data"]["parents"] = parents
-            self.updates[mongo_id]["data"]["hierarchy"] = hierarchy
 
         # Skip custom attributes if didn't change
         if not hier_cust_attrs_ids:

openpype/modules/ftrack/event_handlers_user/action_delivery.py

@@ -1,18 +1,20 @@
 import os
 import copy
 import json
-import shutil
 import collections
 
-import clique
 from bson.objectid import ObjectId
 
-from avalon import pipeline
-from avalon.vendor import filelink
-
 from openpype.api import Anatomy, config
 from openpype.modules.ftrack.lib import BaseAction, statics_icon
 from openpype.modules.ftrack.lib.avalon_sync import CUST_ATTR_ID_KEY
+from openpype.lib.delivery import (
+    path_from_represenation,
+    get_format_dict,
+    check_destination_path,
+    process_single_file,
+    process_sequence
+)
 from avalon.api import AvalonMongoDB
 
 
@@ -450,18 +452,7 @@ class Delivery(BaseAction):
 
         anatomy = Anatomy(project_name)
 
-        format_dict = {}
-        if location_path:
-            location_path = location_path.replace("\\", "/")
-            root_names = anatomy.root_names_from_templates(
-                anatomy.templates["delivery"]
-            )
-            if root_names is None:
-                format_dict["root"] = location_path
-            else:
-                format_dict["root"] = {}
-                for name in root_names:
-                    format_dict["root"][name] = location_path
+        format_dict = get_format_dict(anatomy, location_path)
 
         datetime_data = config.get_datetime_data()
         for repre in repres_to_deliver:
@@ -471,41 +462,15 @@ class Delivery(BaseAction):
                 debug_msg += " with published path {}.".format(source_path)
             self.log.debug(debug_msg)
 
-            # Get destination repre path
             anatomy_data = copy.deepcopy(repre["context"])
-            anatomy_data.update(datetime_data)
-            anatomy_filled = anatomy.format_all(anatomy_data)
-            test_path = anatomy_filled["delivery"][anatomy_name]
+            repre_report_items = check_destination_path(repre["_id"],
+                                                        anatomy,
+                                                        anatomy_data,
+                                                        datetime_data,
+                                                        anatomy_name)
 
-            if not test_path.solved:
-                msg = (
-                    "Missing keys in Representation's context"
-                    " for anatomy template \"{}\"."
-                ).format(anatomy_name)
-
-                if test_path.missing_keys:
-                    keys = ", ".join(test_path.missing_keys)
-                    sub_msg = (
-                        "Representation: {}<br>- Missing keys: \"{}\"<br>"
-                    ).format(str(repre["_id"]), keys)
-
-                if test_path.invalid_types:
-                    items = []
-                    for key, value in test_path.invalid_types.items():
-                        items.append("\"{}\" {}".format(key, str(value)))
-
-                    keys = ", ".join(items)
-                    sub_msg = (
-                        "Representation: {}<br>"
-                        "- Invalid value DataType: \"{}\"<br>"
-                    ).format(str(repre["_id"]), keys)
-
-                report_items[msg].append(sub_msg)
-                self.log.warning(
-                    "{} Representation: \"{}\" Filled: <{}>".format(
-                        msg, str(repre["_id"]), str(test_path)
-                    )
-                )
+            if repre_report_items:
+                report_items.update(repre_report_items)
                 continue
 
             # Get source repre path
@@ -514,151 +479,28 @@ class Delivery(BaseAction):
             if frame:
                 repre["context"]["frame"] = len(str(frame)) * "#"
 
-            repre_path = self.path_from_represenation(repre, anatomy)
+            repre_path = path_from_represenation(repre, anatomy)
             # TODO add backup solution where root of path from component
-            # is repalced with root
+            # is replaced with root
             args = (
                 repre_path,
+                repre,
                 anatomy,
                 anatomy_name,
                 anatomy_data,
                 format_dict,
-                report_items
+                report_items,
+                self.log
             )
             if not frame:
-                self.process_single_file(*args)
+                process_single_file(*args)
             else:
-                self.process_sequence(*args)
+                process_sequence(*args)
 
         return self.report(report_items)
 
-    def process_single_file(
-        self, repre_path, anatomy, anatomy_name, anatomy_data, format_dict,
-        report_items
-    ):
-        anatomy_filled = anatomy.format(anatomy_data)
-        if format_dict:
-            template_result = anatomy_filled["delivery"][anatomy_name]
-            delivery_path = template_result.rootless.format(**format_dict)
-        else:
-            delivery_path = anatomy_filled["delivery"][anatomy_name]
-
-        delivery_folder = os.path.dirname(delivery_path)
-        if not os.path.exists(delivery_folder):
-            os.makedirs(delivery_folder)
-
-        self.copy_file(repre_path, delivery_path)
-
-    def process_sequence(
-        self, repre_path, anatomy, anatomy_name, anatomy_data, format_dict,
-        report_items
-    ):
-        dir_path, file_name = os.path.split(str(repre_path))
-
-        base_name, ext = os.path.splitext(file_name)
-        file_name_items = None
-        if "#" in base_name:
-            file_name_items = [part for part in base_name.split("#") if part]
-
-        elif "%" in base_name:
-            file_name_items = base_name.split("%")
-
-        if not file_name_items:
-            msg = "Source file was not found"
-            report_items[msg].append(repre_path)
-            self.log.warning("{} <{}>".format(msg, repre_path))
-            return
-
-        src_collections, remainder = clique.assemble(os.listdir(dir_path))
-        src_collection = None
-        for col in src_collections:
-            if col.tail != ext:
-                continue
-
-            # skip if collection don't have same basename
-            if not col.head.startswith(file_name_items[0]):
-                continue
-
-            src_collection = col
-            break
-
-        if src_collection is None:
-            # TODO log error!
-            msg = "Source collection of files was not found"
-            report_items[msg].append(repre_path)
-            self.log.warning("{} <{}>".format(msg, repre_path))
-            return
-
-        frame_indicator = "@####@"
-
-        anatomy_data["frame"] = frame_indicator
-        anatomy_filled = anatomy.format(anatomy_data)
-
-        if format_dict:
-            template_result = anatomy_filled["delivery"][anatomy_name]
-            delivery_path = template_result.rootless.format(**format_dict)
-        else:
-            delivery_path = anatomy_filled["delivery"][anatomy_name]
-
-        delivery_folder = os.path.dirname(delivery_path)
-        dst_head, dst_tail = delivery_path.split(frame_indicator)
-        dst_padding = src_collection.padding
-        dst_collection = clique.Collection(
-            head=dst_head,
-            tail=dst_tail,
-            padding=dst_padding
-        )
-
-        if not os.path.exists(delivery_folder):
-            os.makedirs(delivery_folder)
-
-        src_head = src_collection.head
-        src_tail = src_collection.tail
-        for index in src_collection.indexes:
-            src_padding = src_collection.format("{padding}") % index
-            src_file_name = "{}{}{}".format(src_head, src_padding, src_tail)
-            src = os.path.normpath(
-                os.path.join(dir_path, src_file_name)
-            )
-
-            dst_padding = dst_collection.format("{padding}") % index
-            dst = "{}{}{}".format(dst_head, dst_padding, dst_tail)
-
-            self.copy_file(src, dst)
-
-    def path_from_represenation(self, representation, anatomy):
-        try:
-            template = representation["data"]["template"]
-
-        except KeyError:
-            return None
-
-        try:
-            context = representation["context"]
-            context["root"] = anatomy.roots
-            path = pipeline.format_template_with_optional_keys(
-                context, template
-            )
-
-        except KeyError:
-            # Template references unavailable data
-            return None
-
-        return os.path.normpath(path)
-
-    def copy_file(self, src_path, dst_path):
-        if os.path.exists(dst_path):
-            return
-        try:
-            filelink.create(
-                src_path,
-                dst_path,
-                filelink.HARDLINK
-            )
-        except OSError:
-            shutil.copyfile(src_path, dst_path)
-
     def report(self, report_items):
+        """Returns dict with final status of delivery (succes, fail etc.)."""
         items = []
         title = "Delivery report"
         for msg, _items in report_items.items():

openpype/modules/ftrack/lib/avalon_sync.py

@@ -1237,12 +1237,8 @@ class SyncEntitiesFactory:
 
             ent_path_items = [ent["name"] for ent in entity["link"]]
             parents = ent_path_items[1:len(ent_path_items) - 1:]
-            hierarchy = ""
-            if len(parents) > 0:
-                hierarchy = os.path.sep.join(parents)
 
             data["parents"] = parents
-            data["hierarchy"] = hierarchy
             data["tasks"] = self.entities_dict[id].pop("tasks", {})
             self.entities_dict[id]["final_entity"]["data"] = data
             self.entities_dict[id]["final_entity"]["type"] = "asset"
@@ -2169,8 +2165,6 @@ class SyncEntitiesFactory:
             hierarchy = "/".join(parents)
             self.entities_dict[ftrack_id][
                 "final_entity"]["data"]["parents"] = parents
-            self.entities_dict[ftrack_id][
-                "final_entity"]["data"]["hierarchy"] = hierarchy
 
             _parents.append(self.entities_dict[ftrack_id]["name"])
             for child_id in self.entities_dict[ftrack_id]["children"]:
@@ -2181,7 +2175,6 @@ class SyncEntitiesFactory:
                 if "data" not in self.updates[mongo_id]:
                     self.updates[mongo_id]["data"] = {}
                 self.updates[mongo_id]["data"]["parents"] = parents
-                self.updates[mongo_id]["data"]["hierarchy"] = hierarchy
 
     def prepare_project_changes(self):
         ftrack_ent_dict = self.entities_dict[self.ft_project_id]

openpype/modules/ftrack/tray/login_tools.py

@@ -16,6 +16,18 @@ class LoginServerHandler(BaseHTTPRequestHandler):
         self.login_callback = login_callback
         BaseHTTPRequestHandler.__init__(self, *args, **kw)
 
+    def log_message(self, format_str, *args):
+        """Override method of BaseHTTPRequestHandler.
+
+        Goal is to use `print` instead of `sys.stderr.write`
+        """
+        # Change
+        print("%s - - [%s] %s\n" % (
+            self.client_address[0],
+            self.log_date_time_string(),
+            format_str % args
+        ))
+
     def do_GET(self):
         '''Override to handle requests ourselves.'''
         parsed_path = parse.urlparse(self.path)

openpype/plugins/load/delivery.py

@@ -0,0 +1,318 @@
+from collections import defaultdict
+import copy
+
+from Qt import QtWidgets, QtCore, QtGui
+
+from avalon import api, style
+from avalon.api import AvalonMongoDB
+
+from openpype.api import Anatomy, config
+from openpype import resources
+
+from openpype.lib.delivery import (
+    sizeof_fmt,
+    path_from_represenation,
+    get_format_dict,
+    check_destination_path,
+    process_single_file,
+    process_sequence,
+    collect_frames
+)
+
+
+class Delivery(api.SubsetLoader):
+    """Export selected versions to folder structure from Template"""
+
+    is_multiple_contexts_compatible = True
+    sequence_splitter = "__sequence_splitter__"
+
+    representations = ["*"]
+    families = ["*"]
+    tool_names = ["library_loader"]
+
+    label = "Deliver Versions"
+    order = 35
+    icon = "upload"
+    color = "#d8d8d8"
+
+    def message(self, text):
+        msgBox = QtWidgets.QMessageBox()
+        msgBox.setText(text)
+        msgBox.setStyleSheet(style.load_stylesheet())
+        msgBox.setWindowFlags(
+            msgBox.windowFlags() | QtCore.Qt.FramelessWindowHint
+        )
+        msgBox.exec_()
+
+    def load(self, contexts, name=None, namespace=None, options=None):
+        try:
+            dialog = DeliveryOptionsDialog(contexts, self.log)
+            dialog.exec_()
+        except Exception:
+            self.log.error("Failed to deliver versions.", exc_info=True)
+
+
+class DeliveryOptionsDialog(QtWidgets.QDialog):
+    """Dialog to select template where to deliver selected representations."""
+
+    def __init__(self, contexts, log=None, parent=None):
+        super(DeliveryOptionsDialog, self).__init__(parent=parent)
+
+        project = contexts[0]["project"]["name"]
+        self.anatomy = Anatomy(project)
+        self._representations = None
+        self.log = log
+        self.currently_uploaded = 0
+
+        self.dbcon = AvalonMongoDB()
+        self.dbcon.Session["AVALON_PROJECT"] = project
+        self.dbcon.install()
+
+        self._set_representations(contexts)
+
+        self.setWindowTitle("OpenPype - Deliver versions")
+        icon = QtGui.QIcon(resources.pype_icon_filepath())
+        self.setWindowIcon(icon)
+
+        self.setWindowFlags(
+            QtCore.Qt.WindowCloseButtonHint |
+            QtCore.Qt.WindowMinimizeButtonHint
+        )
+        self.setStyleSheet(style.load_stylesheet())
+
+        dropdown = QtWidgets.QComboBox()
+        self.templates = self._get_templates(self.anatomy)
+        for name, _ in self.templates.items():
+            dropdown.addItem(name)
+
+        template_label = QtWidgets.QLabel()
+        template_label.setCursor(QtGui.QCursor(QtCore.Qt.IBeamCursor))
+        template_label.setTextInteractionFlags(QtCore.Qt.TextSelectableByMouse)
+
+        root_line_edit = QtWidgets.QLineEdit()
+
+        repre_checkboxes_layout = QtWidgets.QFormLayout()
+        repre_checkboxes_layout.setContentsMargins(10, 5, 5, 10)
+
+        self._representation_checkboxes = {}
+        for repre in self._get_representation_names():
+            checkbox = QtWidgets.QCheckBox()
+            checkbox.setChecked(False)
+            self._representation_checkboxes[repre] = checkbox
+
+            checkbox.stateChanged.connect(self._update_selected_label)
+            repre_checkboxes_layout.addRow(repre, checkbox)
+
+        selected_label = QtWidgets.QLabel()
+
+        input_widget = QtWidgets.QWidget(self)
+        input_layout = QtWidgets.QFormLayout(input_widget)
+        input_layout.setContentsMargins(10, 15, 5, 5)
+
+        input_layout.addRow("Selected representations", selected_label)
+        input_layout.addRow("Delivery template", dropdown)
+        input_layout.addRow("Template value", template_label)
+        input_layout.addRow("Root", root_line_edit)
+        input_layout.addRow("Representations", repre_checkboxes_layout)
+
+        btn_delivery = QtWidgets.QPushButton("Deliver")
+        btn_delivery.setEnabled(bool(dropdown.currentText()))
+
+        progress_bar = QtWidgets.QProgressBar(self)
+        progress_bar.setMinimum = 0
+        progress_bar.setMaximum = 100
+        progress_bar.setVisible(False)
+
+        text_area = QtWidgets.QTextEdit()
+        text_area.setReadOnly(True)
+        text_area.setVisible(False)
+        text_area.setMinimumHeight(100)
+
+        layout = QtWidgets.QVBoxLayout(self)
+
+        layout.addWidget(input_widget)
+        layout.addStretch(1)
+        layout.addWidget(btn_delivery)
+        layout.addWidget(progress_bar)
+        layout.addWidget(text_area)
+
+        self.selected_label = selected_label
+        self.template_label = template_label
+        self.dropdown = dropdown
+        self.root_line_edit = root_line_edit
+        self.progress_bar = progress_bar
+        self.text_area = text_area
+        self.btn_delivery = btn_delivery
+
+        self.files_selected, self.size_selected = \
+            self._get_counts(self._get_selected_repres())
+
+        self._update_selected_label()
+        self._update_template_value()
+
+        btn_delivery.clicked.connect(self.deliver)
+        dropdown.currentIndexChanged.connect(self._update_template_value)
+
+    def deliver(self):
+        """Main method to loop through all selected representations"""
+        self.progress_bar.setVisible(True)
+        self.btn_delivery.setEnabled(False)
+        QtWidgets.QApplication.processEvents()
+
+        report_items = defaultdict(list)
+
+        selected_repres = self._get_selected_repres()
+
+        datetime_data = config.get_datetime_data()
+        template_name = self.dropdown.currentText()
+        format_dict = get_format_dict(self.anatomy, self.root_line_edit.text())
+        for repre in self._representations:
+            if repre["name"] not in selected_repres:
+                continue
+
+            repre_path = path_from_represenation(repre, self.anatomy)
+
+            anatomy_data = copy.deepcopy(repre["context"])
+            new_report_items = check_destination_path(str(repre["_id"]),
+                                                      self.anatomy,
+                                                      anatomy_data,
+                                                      datetime_data,
+                                                      template_name)
+
+            report_items.update(new_report_items)
+            if new_report_items:
+                continue
+
+            args = [
+                repre_path,
+                repre,
+                self.anatomy,
+                template_name,
+                anatomy_data,
+                format_dict,
+                report_items,
+                self.log
+            ]
+
+            if repre.get("files"):
+                src_paths = []
+                for repre_file in repre["files"]:
+                    src_path = self.anatomy.fill_root(repre_file["path"])
+                    src_paths.append(src_path)
+                sources_and_frames = collect_frames(src_paths)
+
+                for src_path, frame in sources_and_frames.items():
+                    args[0] = src_path
+                    if frame:
+                        anatomy_data["frame"] = frame
+                    new_report_items, uploaded = process_single_file(*args)
+                    report_items.update(new_report_items)
+                    self._update_progress(uploaded)
+            else:  # fallback for Pype2 and representations without files
+                frame = repre['context'].get('frame')
+                if frame:
+                    repre["context"]["frame"] = len(str(frame)) * "#"
+
+                if not frame:
+                    new_report_items, uploaded = process_single_file(*args)
+                else:
+                    new_report_items, uploaded = process_sequence(*args)
+                report_items.update(new_report_items)
+                self._update_progress(uploaded)
+
+        self.text_area.setText(self._format_report(report_items))
+        self.text_area.setVisible(True)
+
+    def _get_representation_names(self):
+        """Get set of representation names for checkbox filtering."""
+        return set([repre["name"] for repre in self._representations])
+
+    def _get_templates(self, anatomy):
+        """Adds list of delivery templates from Anatomy to dropdown."""
+        templates = {}
+        for template_name, value in anatomy.templates["delivery"].items():
+            if not isinstance(value, str) or not value.startswith('{root'):
+                continue
+
+            templates[template_name] = value
+
+        return templates
+
+    def _set_representations(self, contexts):
+        version_ids = [context["version"]["_id"] for context in contexts]
+
+        repres = list(self.dbcon.find({
+            "type": "representation",
+            "parent": {"$in": version_ids}
+        }))
+
+        self._representations = repres
+
+    def _get_counts(self, selected_repres=None):
+        """Returns tuple of number of selected files and their size."""
+        files_selected = 0
+        size_selected = 0
+        for repre in self._representations:
+            if repre["name"] in selected_repres:
+                files = repre.get("files", [])
+                if not files:  # for repre without files, cannot divide by 0
+                    files_selected += 1
+                    size_selected += 0
+                else:
+                    for repre_file in files:
+                        files_selected += 1
+                        size_selected += repre_file["size"]
+
+        return files_selected, size_selected
+
+    def _prepare_label(self):
+        """Provides text with no of selected files and their size."""
+        label = "{} files, size {}".format(self.files_selected,
+                                           sizeof_fmt(self.size_selected))
+        return label
+
+    def _get_selected_repres(self):
+        """Returns list of representation names filtered from checkboxes."""
+        selected_repres = []
+        for repre_name, chckbox in self._representation_checkboxes.items():
+            if chckbox.isChecked():
+                selected_repres.append(repre_name)
+
+        return selected_repres
+
+    def _update_selected_label(self):
+        """Updates label with list of number of selected files."""
+        selected_repres = self._get_selected_repres()
+        self.files_selected, self.size_selected = \
+            self._get_counts(selected_repres)
+        self.selected_label.setText(self._prepare_label())
+
+    def _update_template_value(self, _index=None):
+        """Sets template value to label after selection in dropdown."""
+        name = self.dropdown.currentText()
+        template_value = self.templates.get(name)
+        if template_value:
+            self.btn_delivery.setEnabled(True)
+            self.template_label.setText(template_value)
+
+    def _update_progress(self, uploaded):
+        """Update progress bar after each repre copied."""
+        self.currently_uploaded += uploaded
+
+        ratio = self.currently_uploaded / self.files_selected
+        self.progress_bar.setValue(ratio * self.progress_bar.maximum())
+
+    def _format_report(self, report_items):
+        """Format final result and error details as html."""
+        msg = "Delivery finished"
+        if not report_items:
+            msg += " successfully"
+        else:
+            msg += " with errors"
+        txt = "<h2>{}</h2>".format(msg)
+        for header, data in report_items.items():
+            txt += "<h3>{}</h3>".format(header)
+            for item in data:
+                txt += "{}<br>".format(item)
+
+        return txt

openpype/plugins/publish/extract_review.py

@@ -48,6 +48,8 @@ class ExtractReview(pyblish.api.InstancePlugin):
     video_exts = ["mov", "mp4"]
     supported_exts = image_exts + video_exts
 
+    alpha_exts = ["exr", "png", "dpx"]
+
     # FFmpeg tools paths
     ffmpeg_path = get_ffmpeg_tool_path("ffmpeg")
 
@@ -296,6 +298,13 @@ class ExtractReview(pyblish.api.InstancePlugin):
         ):
             with_audio = False
 
+        input_is_sequence = self.input_is_sequence(repre)
+        input_allow_bg = False
+        if input_is_sequence and repre["files"]:
+            ext = os.path.splitext(repre["files"][0])[1].replace(".", "")
+            if ext in self.alpha_exts:
+                input_allow_bg = True
+
         return {
             "fps": float(instance.data["fps"]),
             "frame_start": frame_start,
@@ -310,7 +319,8 @@ class ExtractReview(pyblish.api.InstancePlugin):
             "resolution_width": instance.data.get("resolutionWidth"),
             "resolution_height": instance.data.get("resolutionHeight"),
             "origin_repre": repre,
-            "input_is_sequence": self.input_is_sequence(repre),
+            "input_is_sequence": input_is_sequence,
+            "input_allow_bg": input_allow_bg,
             "with_audio": with_audio,
             "without_handles": without_handles,
             "handles_are_set": handles_are_set
@@ -470,6 +480,39 @@ class ExtractReview(pyblish.api.InstancePlugin):
         lut_filters = self.lut_filters(new_repre, instance, ffmpeg_input_args)
         ffmpeg_video_filters.extend(lut_filters)
 
+        bg_alpha = 0
+        bg_color = output_def.get("bg_color")
+        if bg_color:
+            bg_red, bg_green, bg_blue, bg_alpha = bg_color
+
+        if bg_alpha > 0:
+            if not temp_data["input_allow_bg"]:
+                self.log.info((
+                    "Output definition has defined BG color input was"
+                    " resolved as does not support adding BG."
+                ))
+            else:
+                bg_color_hex = "#{0:0>2X}{1:0>2X}{2:0>2X}".format(
+                    bg_red, bg_green, bg_blue
+                )
+                bg_color_alpha = float(bg_alpha) / 255
+                bg_color_str = "{}@{}".format(bg_color_hex, bg_color_alpha)
+
+                self.log.info("Applying BG color {}".format(bg_color_str))
+                color_args = [
+                    "split=2[bg][fg]",
+                    "[bg]drawbox=c={}:replace=1:t=fill[bg]".format(
+                        bg_color_str
+                    ),
+                    "[bg][fg]overlay=format=auto"
+                ]
+                # Prepend bg color change before all video filters
+                # NOTE at the time of creation it is required as video filters
+                #   from settings may affect color of BG
+                #   e.g. `eq` can remove alpha from input
+                for arg in reversed(color_args):
+                    ffmpeg_video_filters.insert(0, arg)
+
         # Add argument to override output file
         ffmpeg_output_args.append("-y")
 
@@ -547,10 +590,12 @@ class ExtractReview(pyblish.api.InstancePlugin):
         all_args.append("\"{}\"".format(self.ffmpeg_path))
         all_args.extend(input_args)
         if video_filters:
-            all_args.append("-filter:v {}".format(",".join(video_filters)))
+            all_args.append("-filter:v")
+            all_args.append("\"{}\"".format(",".join(video_filters)))
 
         if audio_filters:
-            all_args.append("-filter:a {}".format(",".join(audio_filters)))
+            all_args.append("-filter:a")
+            all_args.append("\"{}\"".format(",".join(audio_filters)))
 
         all_args.extend(output_args)
 

openpype/settings/defaults/project_settings/global.json

@@ -37,11 +37,11 @@
                                 "ftrackreview"
                             ],
                             "ffmpeg_args": {
-                                "video_filters": [
-                                    "eq=gamma=2.2"
-                                ],
+                                "video_filters": [],
                                 "audio_filters": [],
-                                "input": [],
+                                "input": [
+                                    "-apply_trc gamma22"
+                                ],
                                 "output": [
                                     "-pix_fmt yuv420p",
                                     "-crf 18",
@@ -57,6 +57,12 @@
                             },
                             "width": 0,
                             "height": 0,
+                            "bg_color": [
+                                0,
+                                0,
+                                0,
+                                0
+                            ],
                             "letter_box": {
                                 "enabled": false,
                                 "ratio": 0.0,

openpype/settings/entities/schemas/projects_schema/schemas/schema_global_publish.json

@@ -193,6 +193,15 @@
                                             "minimum": 0,
                                             "maximum": 100000
                                         },
+                                        {
+                                            "type": "label",
+                                            "label": "Background color is used only when input have transparency and Alpha is higher than 0."
+                                        },
+                                        {
+                                            "type": "color",
+                                            "label": "Background color",
+                                            "key": "bg_color"
+                                        },
                                         {
                                             "key": "letter_box",
                                             "label": "Letter box",
@@ -280,24 +289,14 @@
                             "minimum": 0
                         },
                         {
-                            "type": "schema_template",
-                            "name": "template_rgba_color",
-                            "template_data": [
-                                {
-                                    "label": "Font Color",
-                                    "name": "font_color"
-                                }
-                            ]
+                            "type": "color",
+                            "key": "font_color",
+                            "label": "Font Color"
                         },
                         {
-                            "type": "schema_template",
-                            "name": "template_rgba_color",
-                            "template_data": [
-                                {
-                                    "label": "Background Color",
-                                    "name": "bg_color"
-                                }
-                            ]
+                            "type": "color",
+                            "key": "bg_color",
+                            "label": "Background Color"
                         },
                         {
                             "type": "number",

openpype/settings/entities/schemas/projects_schema/schemas/template_rgba_color.json

@@ -1,33 +0,0 @@
-[
-    {
-        "type": "list-strict",
-        "key": "{name}",
-        "label": "{label}",
-        "object_types": [
-            {
-                "label": "R",
-                "type": "number",
-                "minimum": 0,
-                "maximum": 255
-            },
-            {
-                "label": "G",
-                "type": "number",
-                "minimum": 0,
-                "maximum": 255
-            },
-            {
-                "label": "B",
-                "type": "number",
-                "minimum": 0,
-                "maximum": 255
-            },
-            {
-                "label": "A",
-                "type": "number",
-                "minimum": 0,
-                "maximum": 255
-            }
-        ]
-    }
-]

openpype/version.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 """Package declaring Pype version."""
-__version__ = "3.0.0-rc.5"
+__version__ = "3.0.0-rc.6"