[Automated] Merged develop into main

common/openpype_common/distribution/README.md

@@ -0,0 +1,18 @@
+Addon distribution tool
+------------------------
+
+Code in this folder is backend portion of Addon distribution logic for v4 server.
+
+Each host, module will be separate Addon in the future. Each v4 server could run different set of Addons.
+
+Client (running on artist machine) will in the first step ask v4 for list of enabled addons. 
+(It expects list of json documents matching to `addon_distribution.py:AddonInfo` object.)
+Next it will compare presence of enabled addon version in local folder. In the case of missing version of
+an addon, client will use information in the addon to download (from http/shared local disk/git) zip file
+and unzip it.
+
+Required part of addon distribution will be sharing of dependencies (python libraries, utilities) which is not part of this folder.
+
+Location of this folder might change in the future as it will be required for a clint to add this folder to sys.path reliably.
+
+This code needs to be independent on Openpype code as much as possible!

common/openpype_common/distribution/addon_distribution.py

@@ -0,0 +1,208 @@
+import os
+from enum import Enum
+from abc import abstractmethod
+import attr
+import logging
+import requests
+import platform
+import shutil
+
+from .file_handler import RemoteFileHandler
+from .addon_info import AddonInfo
+
+
+class UpdateState(Enum):
+    EXISTS = "exists"
+    UPDATED = "updated"
+    FAILED = "failed"
+
+
+class AddonDownloader:
+    log = logging.getLogger(__name__)
+
+    def __init__(self):
+        self._downloaders = {}
+
+    def register_format(self, downloader_type, downloader):
+        self._downloaders[downloader_type.value] = downloader
+
+    def get_downloader(self, downloader_type):
+        downloader = self._downloaders.get(downloader_type)
+        if not downloader:
+            raise ValueError(f"{downloader_type} not implemented")
+        return downloader()
+
+    @classmethod
+    @abstractmethod
+    def download(cls, source, destination):
+        """Returns url to downloaded addon zip file.
+
+        Args:
+            source (dict): {type:"http", "url":"https://} ...}
+            destination (str): local folder to unzip
+        Returns:
+            (str) local path to addon zip file
+        """
+        pass
+
+    @classmethod
+    def check_hash(cls, addon_path, addon_hash):
+        """Compares 'hash' of downloaded 'addon_url' file.
+
+        Args:
+            addon_path (str): local path to addon zip file
+            addon_hash (str): sha256 hash of zip file
+        Raises:
+            ValueError if hashes doesn't match
+        """
+        if not os.path.exists(addon_path):
+            raise ValueError(f"{addon_path} doesn't exist.")
+        if not RemoteFileHandler.check_integrity(addon_path,
+                                                 addon_hash,
+                                                 hash_type="sha256"):
+            raise ValueError(f"{addon_path} doesn't match expected hash.")
+
+    @classmethod
+    def unzip(cls, addon_zip_path, destination):
+        """Unzips local 'addon_zip_path' to 'destination'.
+
+        Args:
+            addon_zip_path (str): local path to addon zip file
+            destination (str): local folder to unzip
+        """
+        RemoteFileHandler.unzip(addon_zip_path, destination)
+        os.remove(addon_zip_path)
+
+    @classmethod
+    def remove(cls, addon_url):
+        pass
+
+
+class OSAddonDownloader(AddonDownloader):
+
+    @classmethod
+    def download(cls, source, destination):
+        # OS doesnt need to download, unzip directly
+        addon_url = source["path"].get(platform.system().lower())
+        if not os.path.exists(addon_url):
+            raise ValueError("{} is not accessible".format(addon_url))
+        return addon_url
+
+
+class HTTPAddonDownloader(AddonDownloader):
+    CHUNK_SIZE = 100000
+
+    @classmethod
+    def download(cls, source, destination):
+        source_url = source["url"]
+        cls.log.debug(f"Downloading {source_url} to {destination}")
+        file_name = os.path.basename(destination)
+        _, ext = os.path.splitext(file_name)
+        if (ext.replace(".", '') not
+                in set(RemoteFileHandler.IMPLEMENTED_ZIP_FORMATS)):
+            file_name += ".zip"
+        RemoteFileHandler.download_url(source_url,
+                                       destination,
+                                       filename=file_name)
+
+        return os.path.join(destination, file_name)
+
+
+def get_addons_info(server_endpoint):
+    """Returns list of addon information from Server"""
+    # TODO temp
+    # addon_info = AddonInfo(
+    #     **{"name": "openpype_slack",
+    #        "version": "1.0.0",
+    #        "addon_url": "c:/projects/openpype_slack_1.0.0.zip",
+    #        "type": UrlType.FILESYSTEM,
+    #        "hash": "4be25eb6215e91e5894d3c5475aeb1e379d081d3f5b43b4ee15b0891cf5f5658"})  # noqa
+    #
+    # http_addon = AddonInfo(
+    #     **{"name": "openpype_slack",
+    #        "version": "1.0.0",
+    #        "addon_url": "https://drive.google.com/file/d/1TcuV8c2OV8CcbPeWi7lxOdqWsEqQNPYy/view?usp=sharing",  # noqa
+    #        "type": UrlType.HTTP,
+    #        "hash": "4be25eb6215e91e5894d3c5475aeb1e379d081d3f5b43b4ee15b0891cf5f5658"})  # noqa
+
+    response = requests.get(server_endpoint)
+    if not response.ok:
+        raise Exception(response.text)
+
+    addons_info = []
+    for addon in response.json():
+        addons_info.append(AddonInfo(**addon))
+    return addons_info
+
+
+def update_addon_state(addon_infos, destination_folder, factory,
+                       log=None):
+    """Loops through all 'addon_infos', compares local version, unzips.
+
+    Loops through server provided list of dictionaries with information about
+    available addons. Looks if each addon is already present and deployed.
+    If isn't, addon zip gets downloaded and unzipped into 'destination_folder'.
+    Args:
+        addon_infos (list of AddonInfo)
+        destination_folder (str): local path
+        factory (AddonDownloader): factory to get appropriate downloader per
+            addon type
+        log (logging.Logger)
+    Returns:
+        (dict): {"addon_full_name": UpdateState.value
+            (eg. "exists"|"updated"|"failed")
+    """
+    if not log:
+        log = logging.getLogger(__name__)
+
+    download_states = {}
+    for addon in addon_infos:
+        full_name = "{}_{}".format(addon.name, addon.version)
+        addon_dest = os.path.join(destination_folder, full_name)
+
+        if os.path.isdir(addon_dest):
+            log.debug(f"Addon version folder {addon_dest} already exists.")
+            download_states[full_name] = UpdateState.EXISTS.value
+            continue
+
+        for source in addon.sources:
+            download_states[full_name] = UpdateState.FAILED.value
+            try:
+                downloader = factory.get_downloader(source.type)
+                zip_file_path = downloader.download(attr.asdict(source),
+                                                    addon_dest)
+                downloader.check_hash(zip_file_path, addon.hash)
+                downloader.unzip(zip_file_path, addon_dest)
+                download_states[full_name] = UpdateState.UPDATED.value
+                break
+            except Exception:
+                log.warning(f"Error happened during updating {addon.name}",
+                            exc_info=True)
+                if os.path.isdir(addon_dest):
+                    log.debug(f"Cleaning {addon_dest}")
+                    shutil.rmtree(addon_dest)
+
+    return download_states
+
+
+def check_addons(server_endpoint, addon_folder, downloaders):
+    """Main entry point to compare existing addons with those on server.
+
+    Args:
+        server_endpoint (str): url to v4 server endpoint
+        addon_folder (str): local dir path for addons
+        downloaders (AddonDownloader): factory of downloaders
+
+    Raises:
+        (RuntimeError) if any addon failed update
+    """
+    addons_info = get_addons_info(server_endpoint)
+    result = update_addon_state(addons_info,
+                                addon_folder,
+                                downloaders)
+    if UpdateState.FAILED.value in result.values():
+        raise RuntimeError(f"Unable to update some addons {result}")
+
+
+def cli(*args):
+    raise NotImplementedError

common/openpype_common/distribution/addon_info.py

@@ -0,0 +1,80 @@
+import attr
+from enum import Enum
+
+
+class UrlType(Enum):
+    HTTP = "http"
+    GIT = "git"
+    FILESYSTEM = "filesystem"
+
+
+@attr.s
+class MultiPlatformPath(object):
+    windows = attr.ib(default=None)
+    linux = attr.ib(default=None)
+    darwin = attr.ib(default=None)
+
+
+@attr.s
+class AddonSource(object):
+    type = attr.ib()
+
+
+@attr.s
+class LocalAddonSource(AddonSource):
+    path = attr.ib(default=attr.Factory(MultiPlatformPath))
+
+
+@attr.s
+class WebAddonSource(AddonSource):
+    url = attr.ib(default=None)
+
+
+@attr.s
+class VersionData(object):
+    version_data = attr.ib(default=None)
+
+
+@attr.s
+class AddonInfo(object):
+    """Object matching json payload from Server"""
+    name = attr.ib()
+    version = attr.ib()
+    title = attr.ib(default=None)
+    sources = attr.ib(default=attr.Factory(dict))
+    hash = attr.ib(default=None)
+    description = attr.ib(default=None)
+    license = attr.ib(default=None)
+    authors = attr.ib(default=None)
+
+    @classmethod
+    def from_dict(cls, data):
+        sources = []
+
+        production_version = data.get("productionVersion")
+        if not production_version:
+            return
+
+        # server payload contains info about all versions
+        # active addon must have 'productionVersion' and matching version info
+        version_data = data.get("versions", {})[production_version]
+
+        for source in version_data.get("clientSourceInfo", []):
+            if source.get("type") == UrlType.FILESYSTEM.value:
+                source_addon = LocalAddonSource(type=source["type"],
+                                                path=source["path"])
+            if source.get("type") == UrlType.HTTP.value:
+                source_addon = WebAddonSource(type=source["type"],
+                                              url=source["url"])
+
+            sources.append(source_addon)
+
+        return cls(name=data.get("name"),
+                   version=production_version,
+                   sources=sources,
+                   hash=data.get("hash"),
+                   description=data.get("description"),
+                   title=data.get("title"),
+                   license=data.get("license"),
+                   authors=data.get("authors"))
+

common/openpype_common/distribution/file_handler.py

@@ -21,7 +21,7 @@ class RemoteFileHandler:
                                'tar.gz', 'tar.xz', 'tar.bz2']
 
     @staticmethod
-    def calculate_md5(fpath, chunk_size):
+    def calculate_md5(fpath, chunk_size=10000):
         md5 = hashlib.md5()
         with open(fpath, 'rb') as f:
             for chunk in iter(lambda: f.read(chunk_size), b''):
@@ -33,17 +33,45 @@ class RemoteFileHandler:
         return md5 == RemoteFileHandler.calculate_md5(fpath, **kwargs)
 
     @staticmethod
-    def check_integrity(fpath, md5=None):
+    def calculate_sha256(fpath):
+        """Calculate sha256 for content of the file.
+
+        Args:
+             fpath (str): Path to file.
+
+        Returns:
+            str: hex encoded sha256
+
+        """
+        h = hashlib.sha256()
+        b = bytearray(128 * 1024)
+        mv = memoryview(b)
+        with open(fpath, 'rb', buffering=0) as f:
+            for n in iter(lambda: f.readinto(mv), 0):
+                h.update(mv[:n])
+        return h.hexdigest()
+
+    @staticmethod
+    def check_sha256(fpath, sha256, **kwargs):
+        return sha256 == RemoteFileHandler.calculate_sha256(fpath, **kwargs)
+
+    @staticmethod
+    def check_integrity(fpath, hash_value=None, hash_type=None):
         if not os.path.isfile(fpath):
             return False
-        if md5 is None:
+        if hash_value is None:
             return True
-        return RemoteFileHandler.check_md5(fpath, md5)
+        if not hash_type:
+            raise ValueError("Provide hash type, md5 or sha256")
+        if hash_type == 'md5':
+            return RemoteFileHandler.check_md5(fpath, hash_value)
+        if hash_type == "sha256":
+            return RemoteFileHandler.check_sha256(fpath, hash_value)
 
     @staticmethod
     def download_url(
         url, root, filename=None,
-        md5=None, max_redirect_hops=3
+        sha256=None, max_redirect_hops=3
     ):
         """Download a file from a url and place it in root.
         Args:
@@ -51,7 +79,7 @@ class RemoteFileHandler:
             root (str): Directory to place downloaded file in
             filename (str, optional): Name to save the file under.
                 If None, use the basename of the URL
-            md5 (str, optional): MD5 checksum of the download.
+            sha256 (str, optional): sha256 checksum of the download.
                 If None, do not check
             max_redirect_hops (int, optional): Maximum number of redirect
                 hops allowed
@@ -64,7 +92,8 @@ class RemoteFileHandler:
         os.makedirs(root, exist_ok=True)
 
         # check if file is already present locally
-        if RemoteFileHandler.check_integrity(fpath, md5):
+        if RemoteFileHandler.check_integrity(fpath,
+                                             sha256, hash_type="sha256"):
             print('Using downloaded and verified file: ' + fpath)
             return
 
@@ -76,7 +105,7 @@ class RemoteFileHandler:
         file_id = RemoteFileHandler._get_google_drive_file_id(url)
         if file_id is not None:
             return RemoteFileHandler.download_file_from_google_drive(
-                file_id, root, filename, md5)
+                file_id, root, filename, sha256)
 
         # download the file
         try:
@@ -92,20 +121,21 @@ class RemoteFileHandler:
                 raise e
 
         # check integrity of downloaded file
-        if not RemoteFileHandler.check_integrity(fpath, md5):
+        if not RemoteFileHandler.check_integrity(fpath,
+                                                 sha256, hash_type="sha256"):
             raise RuntimeError("File not found or corrupted.")
 
     @staticmethod
     def download_file_from_google_drive(file_id, root,
                                         filename=None,
-                                        md5=None):
+                                        sha256=None):
         """Download a Google Drive file from  and place it in root.
         Args:
             file_id (str): id of file to be downloaded
             root (str): Directory to place downloaded file in
             filename (str, optional): Name to save the file under.
                 If None, use the id of the file.
-            md5 (str, optional): MD5 checksum of the download.
+            sha256 (str, optional): sha256 checksum of the download.
                 If None, do not check
         """
         # Based on https://stackoverflow.com/questions/38511444/python-download-files-from-google-drive-using-url # noqa
@@ -119,8 +149,8 @@ class RemoteFileHandler:
 
         os.makedirs(root, exist_ok=True)
 
-        if os.path.isfile(fpath) and RemoteFileHandler.check_integrity(fpath,
-                                                                       md5):
+        if os.path.isfile(fpath) and RemoteFileHandler.check_integrity(
+                fpath, sha256, hash_type="sha256"):
             print('Using downloaded and verified file: ' + fpath)
         else:
             session = requests.Session()

common/openpype_common/distribution/tests/test_addon_distributtion.py

@@ -0,0 +1,167 @@
+import pytest
+import attr
+import tempfile
+
+from common.openpype_common.distribution.addon_distribution import (
+    AddonDownloader,
+    OSAddonDownloader,
+    HTTPAddonDownloader,
+    AddonInfo,
+    update_addon_state,
+    UpdateState
+)
+from common.openpype_common.distribution.addon_info import UrlType
+
+
+@pytest.fixture
+def addon_downloader():
+    addon_downloader = AddonDownloader()
+    addon_downloader.register_format(UrlType.FILESYSTEM, OSAddonDownloader)
+    addon_downloader.register_format(UrlType.HTTP, HTTPAddonDownloader)
+
+    yield addon_downloader
+
+
+@pytest.fixture
+def http_downloader(addon_downloader):
+    yield addon_downloader.get_downloader(UrlType.HTTP.value)
+
+
+@pytest.fixture
+def temp_folder():
+    yield tempfile.mkdtemp()
+
+
+@pytest.fixture
+def sample_addon_info():
+    addon_info = {
+       "versions": {
+            "1.0.0": {
+                 "clientPyproject": {
+                      "tool": {
+                           "poetry": {
+                            "dependencies": {
+                             "nxtools": "^1.6",
+                             "orjson": "^3.6.7",
+                             "typer": "^0.4.1",
+                             "email-validator": "^1.1.3",
+                             "python": "^3.10",
+                             "fastapi": "^0.73.0"
+                            }
+                       }
+                  }
+                 },
+                 "hasSettings": True,
+                 "clientSourceInfo": [
+                     {
+                         "type": "http",
+                         "url": "https://drive.google.com/file/d/1TcuV8c2OV8CcbPeWi7lxOdqWsEqQNPYy/view?usp=sharing"  # noqa
+                     },
+                     {
+                         "type": "filesystem",
+                         "path": {
+                             "windows": ["P:/sources/some_file.zip",
+                                         "W:/sources/some_file.zip"],  # noqa
+                             "linux": ["/mnt/srv/sources/some_file.zip"],
+                             "darwin": ["/Volumes/srv/sources/some_file.zip"]
+                         }
+                     }
+                 ],
+                 "frontendScopes": {
+                      "project": {
+                       "sidebar": "hierarchy"
+                      }
+                 }
+            }
+       },
+       "description": "",
+       "title": "Slack addon",
+       "name": "openpype_slack",
+       "productionVersion": "1.0.0",
+       "hash": "4be25eb6215e91e5894d3c5475aeb1e379d081d3f5b43b4ee15b0891cf5f5658"  # noqa
+    }
+    yield addon_info
+
+
+def test_register(printer):
+    addon_downloader = AddonDownloader()
+
+    assert len(addon_downloader._downloaders) == 0, "Contains registered"
+
+    addon_downloader.register_format(UrlType.FILESYSTEM, OSAddonDownloader)
+    assert len(addon_downloader._downloaders) == 1, "Should contain one"
+
+
+def test_get_downloader(printer, addon_downloader):
+    assert addon_downloader.get_downloader(UrlType.FILESYSTEM.value), "Should find"  # noqa
+
+    with pytest.raises(ValueError):
+        addon_downloader.get_downloader("unknown"), "Shouldn't find"
+
+
+def test_addon_info(printer, sample_addon_info):
+    """Tests parsing of expected payload from v4 server into AadonInfo."""
+    valid_minimum = {
+        "name": "openpype_slack",
+         "productionVersion": "1.0.0",
+         "versions": {
+             "1.0.0": {
+                 "clientSourceInfo": [
+                     {
+                         "type": "filesystem",
+                         "path": {
+                             "windows": [
+                                 "P:/sources/some_file.zip",
+                                 "W:/sources/some_file.zip"],
+                             "linux": [
+                                 "/mnt/srv/sources/some_file.zip"],
+                             "darwin": [
+                                 "/Volumes/srv/sources/some_file.zip"]  # noqa
+                         }
+                     }
+                 ]
+             }
+         }
+    }
+
+    assert AddonInfo.from_dict(valid_minimum), "Missing required fields"
+
+    valid_minimum["versions"].pop("1.0.0")
+    with pytest.raises(KeyError):
+        assert not AddonInfo.from_dict(valid_minimum), "Must fail without version data"  # noqa
+
+    valid_minimum.pop("productionVersion")
+    assert not AddonInfo.from_dict(
+        valid_minimum), "none if not productionVersion"  # noqa
+
+    addon = AddonInfo.from_dict(sample_addon_info)
+    assert addon, "Should be created"
+    assert addon.name == "openpype_slack", "Incorrect name"
+    assert addon.version == "1.0.0", "Incorrect version"
+
+    with pytest.raises(TypeError):
+        assert addon["name"], "Dict approach not implemented"
+
+    addon_as_dict = attr.asdict(addon)
+    assert addon_as_dict["name"], "Dict approach should work"
+
+
+def test_update_addon_state(printer, sample_addon_info,
+                            temp_folder, addon_downloader):
+    """Tests possible cases of addon update."""
+    addon_info = AddonInfo.from_dict(sample_addon_info)
+    orig_hash = addon_info.hash
+
+    addon_info.hash = "brokenhash"
+    result = update_addon_state([addon_info], temp_folder, addon_downloader)
+    assert result["openpype_slack_1.0.0"] == UpdateState.FAILED.value, \
+        "Update should failed because of wrong hash"
+
+    addon_info.hash = orig_hash
+    result = update_addon_state([addon_info], temp_folder, addon_downloader)
+    assert result["openpype_slack_1.0.0"] == UpdateState.UPDATED.value, \
+        "Addon should have been updated"
+
+    result = update_addon_state([addon_info], temp_folder, addon_downloader)
+    assert result["openpype_slack_1.0.0"] == UpdateState.EXISTS.value, \
+        "Addon should already exist"

openpype/hooks/pre_add_last_workfile_arg.py

@@ -19,6 +19,7 @@ class AddLastWorkfileToLaunchArgs(PreLaunchHook):
         "hiero",
         "houdini",
         "nukestudio",
+        "fusion",
         "blender",
         "photoshop",
         "tvpaint",

openpype/hosts/flame/api/lib.py

@@ -766,11 +766,11 @@ class MediaInfoFile(object):
     _drop_mode = None
     _file_pattern = None
 
-    def __init__(self, path, **kwargs):
+    def __init__(self, path, logger=None):
 
         # replace log if any
-        if kwargs.get("logger"):
-            self.log = kwargs["logger"]
+        if logger:
+            self.log = logger
 
         # test if `dl_get_media_info` paht exists
         self._validate_media_script_path()

openpype/hosts/flame/api/pipeline.py

@@ -90,8 +90,7 @@ def containerise(flame_clip_segment,
 def ls():
     """List available containers.
     """
-    # TODO: ls
-    pass
+    return []
 
 
 def parse_container(tl_segment, validate=True):
@@ -107,6 +106,7 @@ def update_container(tl_segment, data=None):
     # TODO: update_container
     pass
 
+
 def on_pyblish_instance_toggled(instance, old_value, new_value):
     """Toggle node passthrough states on instance toggles."""
 

openpype/hosts/flame/api/plugin.py

@@ -678,6 +678,7 @@ class ClipLoader(LoaderPlugin):
     `update` logic.
 
     """
+    log = log
 
     options = [
         qargparse.Boolean(
@@ -694,16 +695,20 @@ class OpenClipSolver(flib.MediaInfoFile):
 
     log = log
 
-    def __init__(self, openclip_file_path, feed_data):
+    def __init__(self, openclip_file_path, feed_data, logger=None):
         self.out_file = openclip_file_path
 
+        # replace log if any
+        if logger:
+            self.log = logger
+
         # new feed variables:
         feed_path = feed_data.pop("path")
 
         # initialize parent class
         super(OpenClipSolver, self).__init__(
             feed_path,
-            **feed_data
+            logger=logger
         )
 
         # get other metadata
@@ -751,17 +756,18 @@ class OpenClipSolver(flib.MediaInfoFile):
         self.log.info("Building new openClip")
         self.log.debug(">> self.clip_data: {}".format(self.clip_data))
 
-        # clip data comming from MediaInfoFile
-        tmp_xml_feeds = self.clip_data.find('tracks/track/feeds')
-        tmp_xml_feeds.set('currentVersion', self.feed_version_name)
-        for tmp_feed in tmp_xml_feeds:
-            tmp_feed.set('vuid', self.feed_version_name)
+        for tmp_xml_track in self.clip_data.iter("track"):
+            tmp_xml_feeds = tmp_xml_track.find('feeds')
+            tmp_xml_feeds.set('currentVersion', self.feed_version_name)
 
-            # add colorspace if any is set
-            if self.feed_colorspace:
-                self._add_colorspace(tmp_feed, self.feed_colorspace)
+            for tmp_feed in tmp_xml_track.iter("feed"):
+                tmp_feed.set('vuid', self.feed_version_name)
 
-            self._clear_handler(tmp_feed)
+                # add colorspace if any is set
+                if self.feed_colorspace:
+                    self._add_colorspace(tmp_feed, self.feed_colorspace)
+
+                self._clear_handler(tmp_feed)
 
         tmp_xml_versions_obj = self.clip_data.find('versions')
         tmp_xml_versions_obj.set('currentVersion', self.feed_version_name)
@@ -774,6 +780,17 @@ class OpenClipSolver(flib.MediaInfoFile):
 
         self.write_clip_data_to_file(self.out_file, self.clip_data)
 
+    def _get_xml_track_obj_by_uid(self, xml_data, uid):
+        # loop all tracks of input xml data
+        for xml_track in xml_data.iter("track"):
+            track_uid = xml_track.get("uid")
+            self.log.debug(
+                ">> track_uid:uid: {}:{}".format(track_uid, uid))
+
+            # get matching uids
+            if uid == track_uid:
+                return xml_track
+
     def _update_open_clip(self):
         self.log.info("Updating openClip ..")
 
@@ -783,52 +800,81 @@ class OpenClipSolver(flib.MediaInfoFile):
         self.log.debug(">> out_xml: {}".format(out_xml))
         self.log.debug(">> self.clip_data: {}".format(self.clip_data))
 
-        # Get new feed from tmp file
-        tmp_xml_feed = self.clip_data.find('tracks/track/feeds/feed')
+        # loop tmp tracks
+        updated_any = False
+        for tmp_xml_track in self.clip_data.iter("track"):
+            # get tmp track uid
+            tmp_track_uid = tmp_xml_track.get("uid")
+            self.log.debug(">> tmp_track_uid: {}".format(tmp_track_uid))
 
-        self._clear_handler(tmp_xml_feed)
+            # get out data track by uid
+            out_track_element = self._get_xml_track_obj_by_uid(
+                out_xml, tmp_track_uid)
+            self.log.debug(
+                ">> out_track_element: {}".format(out_track_element))
 
-        # update fps from MediaInfoFile class
-        if self.fps:
-            tmp_feed_fps_obj = tmp_xml_feed.find(
-                "startTimecode/rate")
-            tmp_feed_fps_obj.text = str(self.fps)
+            # loop tmp feeds
+            for tmp_xml_feed in tmp_xml_track.iter("feed"):
+                new_path_obj = tmp_xml_feed.find(
+                    "spans/span/path")
+                new_path = new_path_obj.text
 
-        # update start_frame from MediaInfoFile class
-        if self.start_frame:
-            tmp_feed_nb_ticks_obj = tmp_xml_feed.find(
-                "startTimecode/nbTicks")
-            tmp_feed_nb_ticks_obj.text = str(self.start_frame)
+                # check if feed path already exists in track's feeds
+                if (
+                    out_track_element is not None
+                    and self._feed_exists(out_track_element, new_path)
+                ):
+                    continue
 
-        # update drop_mode from MediaInfoFile class
-        if self.drop_mode:
-            tmp_feed_drop_mode_obj = tmp_xml_feed.find(
-                "startTimecode/dropMode")
-            tmp_feed_drop_mode_obj.text = str(self.drop_mode)
+                # rename versions on feeds
+                tmp_xml_feed.set('vuid', self.feed_version_name)
+                self._clear_handler(tmp_xml_feed)
 
-        new_path_obj = tmp_xml_feed.find(
-            "spans/span/path")
-        new_path = new_path_obj.text
+                # update fps from MediaInfoFile class
+                if self.fps is not None:
+                    tmp_feed_fps_obj = tmp_xml_feed.find(
+                        "startTimecode/rate")
+                    tmp_feed_fps_obj.text = str(self.fps)
 
-        feed_added = False
-        if not self._feed_exists(out_xml, new_path):
-            tmp_xml_feed.set('vuid', self.feed_version_name)
-            # Append new temp file feed to .clip source out xml
-            out_track = out_xml.find("tracks/track")
-            # add colorspace if any is set
-            if self.feed_colorspace:
-                self._add_colorspace(tmp_xml_feed, self.feed_colorspace)
+                # update start_frame from MediaInfoFile class
+                if self.start_frame is not None:
+                    tmp_feed_nb_ticks_obj = tmp_xml_feed.find(
+                        "startTimecode/nbTicks")
+                    tmp_feed_nb_ticks_obj.text = str(self.start_frame)
 
-            out_feeds = out_track.find('feeds')
-            out_feeds.set('currentVersion', self.feed_version_name)
-            out_feeds.append(tmp_xml_feed)
+                # update drop_mode from MediaInfoFile class
+                if self.drop_mode is not None:
+                    tmp_feed_drop_mode_obj = tmp_xml_feed.find(
+                        "startTimecode/dropMode")
+                    tmp_feed_drop_mode_obj.text = str(self.drop_mode)
 
-            self.log.info(
-                "Appending new feed: {}".format(
-                    self.feed_version_name))
-            feed_added = True
+                # add colorspace if any is set
+                if self.feed_colorspace is not None:
+                    self._add_colorspace(tmp_xml_feed, self.feed_colorspace)
 
-        if feed_added:
+                # then append/update feed to correct track in output
+                if out_track_element:
+                    self.log.debug("updating track element ..")
+                    # update already present track
+                    out_feeds = out_track_element.find('feeds')
+                    out_feeds.set('currentVersion', self.feed_version_name)
+                    out_feeds.append(tmp_xml_feed)
+
+                    self.log.info(
+                        "Appending new feed: {}".format(
+                            self.feed_version_name))
+                else:
+                    self.log.debug("adding new track element ..")
+                    # create new track as it doesnt exists yet
+                    # set current version to feeds on tmp
+                    tmp_xml_feeds = tmp_xml_track.find('feeds')
+                    tmp_xml_feeds.set('currentVersion', self.feed_version_name)
+                    out_tracks = out_xml.find("tracks")
+                    out_tracks.append(tmp_xml_track)
+
+                updated_any = True
+
+        if updated_any:
             # Append vUID to versions
             out_xml_versions_obj = out_xml.find('versions')
             out_xml_versions_obj.set(

openpype/hosts/flame/hooks/pre_flame_setup.py

@@ -22,6 +22,7 @@ class FlamePrelaunch(PreLaunchHook):
     in environment var FLAME_SCRIPT_DIR.
     """
     app_groups = ["flame"]
+    permissions = 0o777
 
     wtc_script_path = os.path.join(
         opflame.HOST_DIR, "api", "scripts", "wiretap_com.py")
@@ -38,6 +39,7 @@ class FlamePrelaunch(PreLaunchHook):
         """Hook entry method."""
         project_doc = self.data["project_doc"]
         project_name = project_doc["name"]
+        volume_name = _env.get("FLAME_WIRETAP_VOLUME")
 
         # get image io
         project_anatomy = self.data["anatomy"]
@@ -81,7 +83,7 @@ class FlamePrelaunch(PreLaunchHook):
         data_to_script = {
             # from settings
             "host_name": _env.get("FLAME_WIRETAP_HOSTNAME") or hostname,
-            "volume_name": _env.get("FLAME_WIRETAP_VOLUME"),
+            "volume_name": volume_name,
             "group_name": _env.get("FLAME_WIRETAP_GROUP"),
             "color_policy": str(imageio_flame["project"]["colourPolicy"]),
 
@@ -99,8 +101,41 @@ class FlamePrelaunch(PreLaunchHook):
 
         app_arguments = self._get_launch_arguments(data_to_script)
 
+        # fix project data permission issue
+        self._fix_permissions(project_name, volume_name)
+
         self.launch_context.launch_args.extend(app_arguments)
 
+    def _fix_permissions(self, project_name, volume_name):
+        """Work around for project data permissions
+
+        Reported issue: when project is created locally on one machine,
+        it is impossible to migrate it to other machine. Autodesk Flame
+        is crating some unmanagable files which needs to be opened to 0o777.
+
+        Args:
+            project_name (str): project name
+            volume_name (str): studio volume
+        """
+        dirs_to_modify = [
+            "/usr/discreet/project/{}".format(project_name),
+            "/opt/Autodesk/clip/{}/{}.prj".format(volume_name, project_name),
+            "/usr/discreet/clip/{}/{}.prj".format(volume_name, project_name)
+        ]
+
+        for dirtm in dirs_to_modify:
+            for root, dirs, files in os.walk(dirtm):
+                try:
+                    for name in set(dirs) | set(files):
+                        path = os.path.join(root, name)
+                        st = os.stat(path)
+                        if oct(st.st_mode) != self.permissions:
+                            os.chmod(path, self.permissions)
+
+                except OSError as exc:
+                    self.log.warning("Not able to open files: {}".format(exc))
+
+
     def _get_flame_fps(self, fps_num):
         fps_table = {
             float(23.976): "23.976 fps",

openpype/hosts/flame/plugins/create/create_shot_clip.py

@@ -23,10 +23,11 @@ class CreateShotClip(opfapi.Creator):
                 # nested dictionary (only one level allowed
                 # for sections and dict)
                 for _k, _v in v["value"].items():
-                    if presets.get(_k):
+                    if presets.get(_k) is not None:
                         gui_inputs[k][
                             "value"][_k]["value"] = presets[_k]
-            if presets.get(k):
+
+            if presets.get(k) is not None:
                 gui_inputs[k]["value"] = presets[k]
 
         # open widget for plugins inputs

openpype/hosts/flame/plugins/load/load_clip.py

@@ -4,6 +4,7 @@ from pprint import pformat
 import openpype.hosts.flame.api as opfapi
 from openpype.lib import StringTemplate
 
+
 class LoadClip(opfapi.ClipLoader):
     """Load a subset to timeline as clip
 
@@ -60,8 +61,6 @@ class LoadClip(opfapi.ClipLoader):
             "path": self.fname.replace("\\", "/"),
             "colorspace": colorspace,
             "version": "v{:0>3}".format(version_name),
-            "logger": self.log
-
         }
         self.log.debug(pformat(
             loading_context
@@ -69,7 +68,8 @@ class LoadClip(opfapi.ClipLoader):
         self.log.debug(openclip_path)
 
         # make openpype clip file
-        opfapi.OpenClipSolver(openclip_path, loading_context).make()
+        opfapi.OpenClipSolver(
+            openclip_path, loading_context, logger=self.log).make()
 
         # prepare Reel group in actual desktop
         opc = self._get_clip(

openpype/hosts/flame/plugins/load/load_clip_batch.py

@@ -64,8 +64,6 @@ class LoadClipBatch(opfapi.ClipLoader):
             "path": self.fname.replace("\\", "/"),
             "colorspace": colorspace,
             "version": "v{:0>3}".format(version_name),
-            "logger": self.log
-
         }
         self.log.debug(pformat(
             loading_context
@@ -73,7 +71,8 @@ class LoadClipBatch(opfapi.ClipLoader):
         self.log.debug(openclip_path)
 
         # make openpype clip file
-        opfapi.OpenClipSolver(openclip_path, loading_context).make()
+        opfapi.OpenClipSolver(
+            openclip_path, loading_context, logger=self.log).make()
 
         # prepare Reel group in actual desktop
         opc = self._get_clip(

openpype/hosts/flame/plugins/publish/collect_timeline_instances.py

@@ -131,9 +131,8 @@ class CollectTimelineInstances(pyblish.api.ContextPlugin):
                 "fps": self.fps,
                 "workfileFrameStart": workfile_start,
                 "sourceFirstFrame": int(first_frame),
-                "notRetimedHandles": (
-                    not marker_data.get("retimedHandles")),
-                "notRetimedFramerange": (
+                "retimedHandles": marker_data.get("retimedHandles"),
+                "shotDurationFromSource": (
                     not marker_data.get("retimedFramerange")),
                 "path": file_path,
                 "flameAddTasks": self.add_tasks,

openpype/hosts/flame/plugins/publish/extract_subset_resources.py

@@ -1,7 +1,6 @@
 import os
 import re
 import tempfile
-from pprint import pformat
 from copy import deepcopy
 
 import pyblish.api
@@ -80,10 +79,10 @@ class ExtractSubsetResources(openpype.api.Extractor):
         retimed_data = self._get_retimed_attributes(instance)
 
         # get individual keys
-        r_handle_start = retimed_data["handle_start"]
-        r_handle_end = retimed_data["handle_end"]
-        r_source_dur = retimed_data["source_duration"]
-        r_speed = retimed_data["speed"]
+        retimed_handle_start = retimed_data["handle_start"]
+        retimed_handle_end = retimed_data["handle_end"]
+        retimed_source_duration = retimed_data["source_duration"]
+        retimed_speed = retimed_data["speed"]
 
         # get handles value - take only the max from both
         handle_start = instance.data["handleStart"]
@@ -97,22 +96,23 @@ class ExtractSubsetResources(openpype.api.Extractor):
         source_end_handles = instance.data["sourceEndH"]
 
         # retime if needed
-        if r_speed != 1.0:
+        if retimed_speed != 1.0:
             if retimed_handles:
                 # handles are retimed
                 source_start_handles = (
-                    instance.data["sourceStart"] - r_handle_start)
+                    instance.data["sourceStart"] - retimed_handle_start)
                 source_end_handles = (
                     source_start_handles
-                    + (r_source_dur - 1)
-                    + r_handle_start
-                    + r_handle_end
+                    + (retimed_source_duration - 1)
+                    + retimed_handle_start
+                    + retimed_handle_end
                 )
+
             else:
                 # handles are not retimed
                 source_end_handles = (
                     source_start_handles
-                    + (r_source_dur - 1)
+                    + (retimed_source_duration - 1)
                     + handle_start
                     + handle_end
                 )
@@ -121,11 +121,11 @@ class ExtractSubsetResources(openpype.api.Extractor):
         frame_start_handle = frame_start - handle_start
         repre_frame_start = frame_start_handle
         if include_handles:
-            if r_speed == 1.0 or not retimed_handles:
+            if retimed_speed == 1.0 or not retimed_handles:
                 frame_start_handle = frame_start
             else:
                 frame_start_handle = (
-                    frame_start - handle_start) + r_handle_start
+                    frame_start - handle_start) + retimed_handle_start
 
         self.log.debug("_ frame_start_handle: {}".format(
             frame_start_handle))
@@ -136,6 +136,9 @@ class ExtractSubsetResources(openpype.api.Extractor):
         source_duration_handles = (
             source_end_handles - source_start_handles) + 1
 
+        self.log.debug("_ source_duration_handles: {}".format(
+            source_duration_handles))
+
         # create staging dir path
         staging_dir = self.staging_dir(instance)
 
@@ -159,15 +162,30 @@ class ExtractSubsetResources(openpype.api.Extractor):
         if version_data:
             instance.data["versionData"].update(version_data)
 
-        if r_speed != 1.0:
-            instance.data["versionData"].update({
-                "frameStart": frame_start_handle,
-                "frameEnd": (
-                    (frame_start_handle + source_duration_handles - 1)
-                    - (r_handle_start + r_handle_end)
-                )
-            })
-        self.log.debug("_ i_version_data: {}".format(
+        # version data start frame
+        version_frame_start = frame_start
+        if include_handles:
+            version_frame_start = frame_start_handle
+        if retimed_speed != 1.0:
+            if retimed_handles:
+                instance.data["versionData"].update({
+                    "frameStart": version_frame_start,
+                    "frameEnd": (
+                        (version_frame_start + source_duration_handles - 1)
+                        - (retimed_handle_start + retimed_handle_end)
+                    )
+                })
+            else:
+                instance.data["versionData"].update({
+                    "handleStart": handle_start,
+                    "handleEnd": handle_end,
+                    "frameStart": version_frame_start,
+                    "frameEnd": (
+                        (version_frame_start + source_duration_handles - 1)
+                        - (handle_start + handle_end)
+                    )
+                })
+        self.log.debug("_ version_data: {}".format(
             instance.data["versionData"]
         ))
 

openpype/hosts/fusion/addon.py

@@ -19,5 +19,14 @@ class FusionAddon(OpenPypeModule, IHostAddon):
             os.path.join(FUSION_HOST_DIR, "hooks")
         ]
 
+    def add_implementation_envs(self, env, _app):
+        # Set default values if are not already set via settings
+        defaults = {
+            "OPENPYPE_LOG_NO_COLORS": "Yes"
+        }
+        for key, value in defaults.items():
+            if not env.get(key):
+                env[key] = value
+
     def get_workfile_extensions(self):
         return [".comp"]

openpype/hosts/fusion/api/__init__.py

@@ -5,10 +5,7 @@ from .pipeline import (
     ls,
 
     imprint_container,
-    parse_container,
-
-    get_current_comp,
-    comp_lock_and_undo_chunk
+    parse_container
 )
 
 from .workio import (
@@ -22,8 +19,10 @@ from .workio import (
 
 from .lib import (
     maintained_selection,
-    get_additional_data,
-    update_frame_range
+    update_frame_range,
+    set_asset_framerange,
+    get_current_comp,
+    comp_lock_and_undo_chunk
 )
 
 from .menu import launch_openpype_menu
@@ -38,9 +37,6 @@ __all__ = [
     "imprint_container",
     "parse_container",
 
-    "get_current_comp",
-    "comp_lock_and_undo_chunk",
-
     # workio
     "open_file",
     "save_file",
@@ -51,8 +47,10 @@ __all__ = [
 
     # lib
     "maintained_selection",
-    "get_additional_data",
     "update_frame_range",
+    "set_asset_framerange",
+    "get_current_comp",
+    "comp_lock_and_undo_chunk",
 
     # menu
     "launch_openpype_menu",

openpype/hosts/fusion/api/lib.py

@@ -5,6 +5,7 @@ import contextlib
 
 from Qt import QtGui
 
+from openpype.lib import Logger
 from openpype.client import (
     get_asset_by_name,
     get_subset_by_name,
@@ -17,13 +18,14 @@ from openpype.pipeline import (
     switch_container,
     legacy_io,
 )
-from .pipeline import get_current_comp, comp_lock_and_undo_chunk
+from openpype.pipeline.context_tools import get_current_project_asset
 
 self = sys.modules[__name__]
 self._project = None
 
 
-def update_frame_range(start, end, comp=None, set_render_range=True):
+def update_frame_range(start, end, comp=None, set_render_range=True,
+                       handle_start=0, handle_end=0):
     """Set Fusion comp's start and end frame range
 
     Args:
@@ -32,6 +34,8 @@ def update_frame_range(start, end, comp=None, set_render_range=True):
         comp (object, Optional): comp object from fusion
         set_render_range (bool, Optional): When True this will also set the
             composition's render start and end frame.
+        handle_start (float, int, Optional): frame handles before start frame
+        handle_end (float, int, Optional): frame handles after end frame
 
     Returns:
         None
@@ -41,11 +45,16 @@ def update_frame_range(start, end, comp=None, set_render_range=True):
     if not comp:
         comp = get_current_comp()
 
+    # Convert any potential none type to zero
+    handle_start = handle_start or 0
+    handle_end = handle_end or 0
+
     attrs = {
-        "COMPN_GlobalStart": start,
-        "COMPN_GlobalEnd": end
+        "COMPN_GlobalStart": start - handle_start,
+        "COMPN_GlobalEnd": end + handle_end
     }
 
+    # set frame range
     if set_render_range:
         attrs.update({
             "COMPN_RenderStart": start,
@@ -56,24 +65,116 @@ def update_frame_range(start, end, comp=None, set_render_range=True):
         comp.SetAttrs(attrs)
 
 
-def get_additional_data(container):
-    """Get Fusion related data for the container
+def set_asset_framerange():
+    """Set Comp's frame range based on current asset"""
+    asset_doc = get_current_project_asset()
+    start = asset_doc["data"]["frameStart"]
+    end = asset_doc["data"]["frameEnd"]
+    handle_start = asset_doc["data"]["handleStart"]
+    handle_end = asset_doc["data"]["handleEnd"]
+    update_frame_range(start, end, set_render_range=True,
+                       handle_start=handle_start,
+                       handle_end=handle_end)
 
-    Args:
-        container(dict): the container found by the ls() function
 
-    Returns:
-        dict
+def set_asset_resolution():
+    """Set Comp's resolution width x height default based on current asset"""
+    asset_doc = get_current_project_asset()
+    width = asset_doc["data"]["resolutionWidth"]
+    height = asset_doc["data"]["resolutionHeight"]
+    comp = get_current_comp()
+
+    print("Setting comp frame format resolution to {}x{}".format(width,
+                                                                 height))
+    comp.SetPrefs({
+        "Comp.FrameFormat.Width": width,
+        "Comp.FrameFormat.Height": height,
+    })
+
+
+def validate_comp_prefs(comp=None):
+    """Validate current comp defaults with asset settings.
+
+    Validates fps, resolutionWidth, resolutionHeight, aspectRatio.
+
+    This does *not* validate frameStart, frameEnd, handleStart and handleEnd.
     """
 
-    tool = container["_tool"]
-    tile_color = tool.TileColor
-    if tile_color is None:
-        return {}
+    if comp is None:
+        comp = get_current_comp()
 
-    return {"color": QtGui.QColor.fromRgbF(tile_color["R"],
-                                           tile_color["G"],
-                                           tile_color["B"])}
+    log = Logger.get_logger("validate_comp_prefs")
+
+    fields = [
+        "name",
+        "data.fps",
+        "data.resolutionWidth",
+        "data.resolutionHeight",
+        "data.pixelAspect"
+    ]
+    asset_doc = get_current_project_asset(fields=fields)
+    asset_data = asset_doc["data"]
+
+    comp_frame_format_prefs = comp.GetPrefs("Comp.FrameFormat")
+
+    # Pixel aspect ratio in Fusion is set as AspectX and AspectY so we convert
+    # the data to something that is more sensible to Fusion
+    asset_data["pixelAspectX"] = asset_data.pop("pixelAspect")
+    asset_data["pixelAspectY"] = 1.0
+
+    validations = [
+        ("fps", "Rate", "FPS"),
+        ("resolutionWidth", "Width", "Resolution Width"),
+        ("resolutionHeight", "Height", "Resolution Height"),
+        ("pixelAspectX", "AspectX", "Pixel Aspect Ratio X"),
+        ("pixelAspectY", "AspectY", "Pixel Aspect Ratio Y")
+    ]
+
+    invalid = []
+    for key, comp_key, label in validations:
+        asset_value = asset_data[key]
+        comp_value = comp_frame_format_prefs.get(comp_key)
+        if asset_value != comp_value:
+            # todo: Actually show dialog to user instead of just logging
+            log.warning(
+                "Comp {pref} {value} does not match asset "
+                "'{asset_name}' {pref} {asset_value}".format(
+                    pref=label,
+                    value=comp_value,
+                    asset_name=asset_doc["name"],
+                    asset_value=asset_value)
+            )
+
+            invalid_msg = "{} {} should be {}".format(label,
+                                                      comp_value,
+                                                      asset_value)
+            invalid.append(invalid_msg)
+
+    if invalid:
+
+        def _on_repair():
+            attributes = dict()
+            for key, comp_key, _label in validations:
+                value = asset_data[key]
+                comp_key_full = "Comp.FrameFormat.{}".format(comp_key)
+                attributes[comp_key_full] = value
+            comp.SetPrefs(attributes)
+
+        from . import menu
+        from openpype.widgets import popup
+        from openpype.style import load_stylesheet
+        dialog = popup.Popup(parent=menu.menu)
+        dialog.setWindowTitle("Fusion comp has invalid configuration")
+
+        msg = "Comp preferences mismatches '{}'".format(asset_doc["name"])
+        msg += "\n" + "\n".join(invalid)
+        dialog.setMessage(msg)
+        dialog.setButtonText("Repair")
+        dialog.on_clicked.connect(_on_repair)
+        dialog.show()
+        dialog.raise_()
+        dialog.activateWindow()
+        dialog.setStyleSheet(load_stylesheet())
 
 
 def switch_item(container,
@@ -195,3 +296,21 @@ def get_frame_path(path):
         padding = 4  # default Fusion padding
 
     return filename, padding, ext
+
+
+def get_current_comp():
+    """Hack to get current comp in this session"""
+    fusion = getattr(sys.modules["__main__"], "fusion", None)
+    return fusion.CurrentComp if fusion else None
+
+
+@contextlib.contextmanager
+def comp_lock_and_undo_chunk(comp, undo_queue_name="Script CMD"):
+    """Lock comp and open an undo chunk during the context"""
+    try:
+        comp.Lock()
+        comp.StartUndo(undo_queue_name)
+        yield
+    finally:
+        comp.Unlock()
+        comp.EndUndo()

openpype/hosts/fusion/api/menu.py

@@ -1,43 +1,25 @@
-import os
 import sys
 
-from Qt import QtWidgets, QtCore
+from Qt import QtWidgets, QtCore, QtGui
 
-from openpype import style
 from openpype.tools.utils import host_tools
-
+from openpype.style import load_stylesheet
+from openpype.lib import register_event_callback
 from openpype.hosts.fusion.scripts import (
     set_rendermode,
     duplicate_with_inputs
 )
+from openpype.hosts.fusion.api.lib import (
+    set_asset_framerange,
+    set_asset_resolution
+)
+from openpype.pipeline import legacy_io
+from openpype.resources import get_openpype_icon_filepath
 
+from .pulse import FusionPulse
 
-def load_stylesheet():
-    path = os.path.join(os.path.dirname(__file__), "menu_style.qss")
-    if not os.path.exists(path):
-        print("Unable to load stylesheet, file not found in resources")
-        return ""
-
-    with open(path, "r") as file_stream:
-        stylesheet = file_stream.read()
-    return stylesheet
-
-
-class Spacer(QtWidgets.QWidget):
-    def __init__(self, height, *args, **kwargs):
-        super(Spacer, self).__init__(*args, **kwargs)
-
-        self.setFixedHeight(height)
-
-        real_spacer = QtWidgets.QWidget(self)
-        real_spacer.setObjectName("Spacer")
-        real_spacer.setFixedHeight(height)
-
-        layout = QtWidgets.QVBoxLayout(self)
-        layout.setContentsMargins(0, 0, 0, 0)
-        layout.addWidget(real_spacer)
-
-        self.setLayout(layout)
+self = sys.modules[__name__]
+self.menu = None
 
 
 class OpenPypeMenu(QtWidgets.QWidget):
@@ -46,15 +28,29 @@ class OpenPypeMenu(QtWidgets.QWidget):
 
         self.setObjectName("OpenPypeMenu")
 
+        icon_path = get_openpype_icon_filepath()
+        icon = QtGui.QIcon(icon_path)
+        self.setWindowIcon(icon)
+
         self.setWindowFlags(
             QtCore.Qt.Window
             | QtCore.Qt.CustomizeWindowHint
             | QtCore.Qt.WindowTitleHint
+            | QtCore.Qt.WindowMinimizeButtonHint
             | QtCore.Qt.WindowCloseButtonHint
             | QtCore.Qt.WindowStaysOnTopHint
         )
         self.render_mode_widget = None
         self.setWindowTitle("OpenPype")
+
+        asset_label = QtWidgets.QLabel("Context", self)
+        asset_label.setStyleSheet("""QLabel {
+            font-size: 14px;
+            font-weight: 600;
+            color: #5f9fb8;
+        }""")
+        asset_label.setAlignment(QtCore.Qt.AlignHCenter)
+
         workfiles_btn = QtWidgets.QPushButton("Workfiles...", self)
         create_btn = QtWidgets.QPushButton("Create...", self)
         publish_btn = QtWidgets.QPushButton("Publish...", self)
@@ -62,77 +58,107 @@ class OpenPypeMenu(QtWidgets.QWidget):
         manager_btn = QtWidgets.QPushButton("Manage...", self)
         libload_btn = QtWidgets.QPushButton("Library...", self)
         rendermode_btn = QtWidgets.QPushButton("Set render mode...", self)
+        set_framerange_btn = QtWidgets.QPushButton("Set Frame Range", self)
+        set_resolution_btn = QtWidgets.QPushButton("Set Resolution", self)
         duplicate_with_inputs_btn = QtWidgets.QPushButton(
             "Duplicate with input connections", self
         )
-        reset_resolution_btn = QtWidgets.QPushButton(
-            "Reset Resolution from project", self
-        )
 
         layout = QtWidgets.QVBoxLayout(self)
         layout.setContentsMargins(10, 20, 10, 20)
 
+        layout.addWidget(asset_label)
+
+        layout.addSpacing(20)
+
         layout.addWidget(workfiles_btn)
+
+        layout.addSpacing(20)
+
         layout.addWidget(create_btn)
-        layout.addWidget(publish_btn)
         layout.addWidget(load_btn)
+        layout.addWidget(publish_btn)
         layout.addWidget(manager_btn)
 
-        layout.addWidget(Spacer(15, self))
+        layout.addSpacing(20)
 
         layout.addWidget(libload_btn)
 
-        layout.addWidget(Spacer(15, self))
+        layout.addSpacing(20)
 
+        layout.addWidget(set_framerange_btn)
+        layout.addWidget(set_resolution_btn)
         layout.addWidget(rendermode_btn)
 
-        layout.addWidget(Spacer(15, self))
+        layout.addSpacing(20)
 
         layout.addWidget(duplicate_with_inputs_btn)
-        layout.addWidget(reset_resolution_btn)
 
         self.setLayout(layout)
 
+        # Store reference so we can update the label
+        self.asset_label = asset_label
+
         workfiles_btn.clicked.connect(self.on_workfile_clicked)
         create_btn.clicked.connect(self.on_create_clicked)
         publish_btn.clicked.connect(self.on_publish_clicked)
         load_btn.clicked.connect(self.on_load_clicked)
         manager_btn.clicked.connect(self.on_manager_clicked)
         libload_btn.clicked.connect(self.on_libload_clicked)
-        rendermode_btn.clicked.connect(self.on_rendernode_clicked)
+        rendermode_btn.clicked.connect(self.on_rendermode_clicked)
         duplicate_with_inputs_btn.clicked.connect(
             self.on_duplicate_with_inputs_clicked)
-        reset_resolution_btn.clicked.connect(self.on_reset_resolution_clicked)
+        set_resolution_btn.clicked.connect(self.on_set_resolution_clicked)
+        set_framerange_btn.clicked.connect(self.on_set_framerange_clicked)
+
+        self._callbacks = []
+        self.register_callback("taskChanged", self.on_task_changed)
+        self.on_task_changed()
+
+        # Force close current process if Fusion is closed
+        self._pulse = FusionPulse(parent=self)
+        self._pulse.start()
+
+    def on_task_changed(self):
+        # Update current context label
+        label = legacy_io.Session["AVALON_ASSET"]
+        self.asset_label.setText(label)
+
+    def register_callback(self, name, fn):
+
+        # Create a wrapper callback that we only store
+        # for as long as we want it to persist as callback
+        def _callback(*args):
+            fn()
+
+        self._callbacks.append(_callback)
+        register_event_callback(name, _callback)
+
+    def deregister_all_callbacks(self):
+        self._callbacks[:] = []
 
     def on_workfile_clicked(self):
-        print("Clicked Workfile")
         host_tools.show_workfiles()
 
     def on_create_clicked(self):
-        print("Clicked Create")
         host_tools.show_creator()
 
     def on_publish_clicked(self):
-        print("Clicked Publish")
         host_tools.show_publish()
 
     def on_load_clicked(self):
-        print("Clicked Load")
         host_tools.show_loader(use_context=True)
 
     def on_manager_clicked(self):
-        print("Clicked Manager")
         host_tools.show_scene_inventory()
 
     def on_libload_clicked(self):
-        print("Clicked Library")
         host_tools.show_library_loader()
 
-    def on_rendernode_clicked(self):
-        print("Clicked Set Render Mode")
+    def on_rendermode_clicked(self):
         if self.render_mode_widget is None:
             window = set_rendermode.SetRenderMode()
-            window.setStyleSheet(style.load_stylesheet())
+            window.setStyleSheet(load_stylesheet())
             window.show()
             self.render_mode_widget = window
         else:
@@ -140,15 +166,16 @@ class OpenPypeMenu(QtWidgets.QWidget):
 
     def on_duplicate_with_inputs_clicked(self):
         duplicate_with_inputs.duplicate_with_input_connections()
-        print("Clicked Set Colorspace")
 
-    def on_reset_resolution_clicked(self):
-        print("Clicked Reset Resolution")
+    def on_set_resolution_clicked(self):
+        set_asset_resolution()
+
+    def on_set_framerange_clicked(self):
+        set_asset_framerange()
 
 
 def launch_openpype_menu():
     app = QtWidgets.QApplication(sys.argv)
-    app.setQuitOnLastWindowClosed(False)
 
     pype_menu = OpenPypeMenu()
 
@@ -156,5 +183,8 @@ def launch_openpype_menu():
     pype_menu.setStyleSheet(stylesheet)
 
     pype_menu.show()
+    self.menu = pype_menu
 
-    sys.exit(app.exec_())
+    result = app.exec_()
+    print("Shutting down..")
+    sys.exit(result)

openpype/hosts/fusion/api/menu_style.qss

@@ -1,29 +0,0 @@
-QWidget {
-    background-color: #282828;
-    border-radius: 3;
-}
-
-QPushButton {
-    border: 1px solid #090909;
-    background-color: #201f1f;
-    color: #ffffff;
-    padding: 5;
-}
-
-QPushButton:focus {
-    background-color: "#171717";
-    color: #d0d0d0;
-}
-
-QPushButton:hover {
-    background-color: "#171717";
-    color: #e64b3d;
-}
-
-#OpenPypeMenu {
-    border: 1px solid #fef9ef;
-}
-
-#Spacer {
-    background-color: #282828;
-}

openpype/hosts/fusion/api/pipeline.py

@@ -2,13 +2,14 @@
 Basic avalon integration
 """
 import os
-import sys
 import logging
-import contextlib
 
 import pyblish.api
 
-from openpype.lib import Logger
+from openpype.lib import (
+    Logger,
+    register_event_callback
+)
 from openpype.pipeline import (
     register_loader_plugin_path,
     register_creator_plugin_path,
@@ -18,7 +19,15 @@ from openpype.pipeline import (
     deregister_inventory_action_path,
     AVALON_CONTAINER_ID,
 )
+from openpype.pipeline.load import any_outdated_containers
 from openpype.hosts.fusion import FUSION_HOST_DIR
+from openpype.tools.utils import host_tools
+
+from .lib import (
+    get_current_comp,
+    comp_lock_and_undo_chunk,
+    validate_comp_prefs
+)
 
 log = Logger.get_logger(__name__)
 
@@ -39,7 +48,7 @@ class CompLogHandler(logging.Handler):
 
 
 def install():
-    """Install fusion-specific functionality of avalon-core.
+    """Install fusion-specific functionality of OpenPype.
 
     This is where you install menus and register families, data
     and loaders into fusion.
@@ -51,7 +60,7 @@ def install():
 
     """
     # Remove all handlers associated with the root logger object, because
-    # that one sometimes logs as "warnings" incorrectly.
+    # that one always logs as "warnings" incorrectly.
     for handler in logging.root.handlers[:]:
         logging.root.removeHandler(handler)
 
@@ -63,8 +72,6 @@ def install():
     logger.addHandler(handler)
     logger.setLevel(logging.DEBUG)
 
-    log.info("openpype.hosts.fusion installed")
-
     pyblish.api.register_host("fusion")
     pyblish.api.register_plugin_path(PUBLISH_PATH)
     log.info("Registering Fusion plug-ins..")
@@ -77,6 +84,11 @@ def install():
         "instanceToggled", on_pyblish_instance_toggled
     )
 
+    # Fusion integration currently does not attach to direct callbacks of
+    # the application. So we use workfile callbacks to allow similar behavior
+    # on save and open
+    register_event_callback("workfile.open.after", on_after_open)
+
 
 def uninstall():
     """Uninstall all that was installed
@@ -102,7 +114,7 @@ def uninstall():
     )
 
 
-def on_pyblish_instance_toggled(instance, new_value, old_value):
+def on_pyblish_instance_toggled(instance, old_value, new_value):
     """Toggle saver tool passthrough states on instance toggles."""
     comp = instance.context.data.get("currentComp")
     if not comp:
@@ -125,6 +137,38 @@ def on_pyblish_instance_toggled(instance, new_value, old_value):
                 tool.SetAttrs({"TOOLB_PassThrough": passthrough})
 
 
+def on_after_open(_event):
+    comp = get_current_comp()
+    validate_comp_prefs(comp)
+
+    if any_outdated_containers():
+        log.warning("Scene has outdated content.")
+
+        # Find OpenPype menu to attach to
+        from . import menu
+
+        def _on_show_scene_inventory():
+            # ensure that comp is active
+            frame = comp.CurrentFrame
+            if not frame:
+                print("Comp is closed, skipping show scene inventory")
+                return
+            frame.ActivateFrame()   # raise comp window
+            host_tools.show_scene_inventory()
+
+        from openpype.widgets import popup
+        from openpype.style import load_stylesheet
+        dialog = popup.Popup(parent=menu.menu)
+        dialog.setWindowTitle("Fusion comp has outdated content")
+        dialog.setMessage("There are outdated containers in "
+                          "your Fusion comp.")
+        dialog.on_clicked.connect(_on_show_scene_inventory)
+        dialog.show()
+        dialog.raise_()
+        dialog.activateWindow()
+        dialog.setStyleSheet(load_stylesheet())
+
+
 def ls():
     """List containers from active Fusion scene
 
@@ -210,19 +254,3 @@ def parse_container(tool):
     return container
 
 
-def get_current_comp():
-    """Hack to get current comp in this session"""
-    fusion = getattr(sys.modules["__main__"], "fusion", None)
-    return fusion.CurrentComp if fusion else None
-
-
-@contextlib.contextmanager
-def comp_lock_and_undo_chunk(comp, undo_queue_name="Script CMD"):
-    """Lock comp and open an undo chunk during the context"""
-    try:
-        comp.Lock()
-        comp.StartUndo(undo_queue_name)
-        yield
-    finally:
-        comp.Unlock()
-        comp.EndUndo()

openpype/hosts/fusion/api/pulse.py

@@ -0,0 +1,60 @@
+import os
+import sys
+
+from Qt import QtCore
+
+
+class PulseThread(QtCore.QThread):
+    no_response = QtCore.Signal()
+
+    def __init__(self, parent=None):
+        super(PulseThread, self).__init__(parent=parent)
+
+    def run(self):
+        app = getattr(sys.modules["__main__"], "app", None)
+
+        # Interval in milliseconds
+        interval = os.environ.get("OPENPYPE_FUSION_PULSE_INTERVAL", 1000)
+
+        while True:
+            if self.isInterruptionRequested():
+                return
+            try:
+                app.Test()
+            except Exception:
+                self.no_response.emit()
+
+            self.msleep(interval)
+
+
+class FusionPulse(QtCore.QObject):
+    """A Timer that checks whether host app is still alive.
+
+    This checks whether the Fusion process is still active at a certain
+    interval. This is useful due to how Fusion runs its scripts. Each script
+    runs in its own environment and process (a `fusionscript` process each).
+    If Fusion would go down and we have a UI process running at the same time
+    then it can happen that the `fusionscript.exe` will remain running in the
+    background in limbo due to e.g. a Qt interface's QApplication that keeps
+    running infinitely.
+
+    Warning:
+        When the host is not detected this will automatically exit
+        the current process.
+
+    """
+
+    def __init__(self, parent=None):
+        super(FusionPulse, self).__init__(parent=parent)
+        self._thread = PulseThread(parent=self)
+        self._thread.no_response.connect(self.on_no_response)
+
+    def on_no_response(self):
+        print("Pulse detected no response from Fusion..")
+        sys.exit(1)
+
+    def start(self):
+        self._thread.start()
+
+    def stop(self):
+        self._thread.requestInterruption()

openpype/hosts/fusion/api/workio.py

@@ -2,7 +2,7 @@
 import sys
 import os
 
-from .pipeline import get_current_comp
+from .lib import get_current_comp
 
 
 def file_extensions():

openpype/hosts/fusion/deploy/Config/openpype_menu.fu

@@ -0,0 +1,60 @@
+{
+    Action
+    {
+        ID = "OpenPype_Menu",
+        Category = "OpenPype",
+        Name = "OpenPype Menu",
+
+        Targets =
+        {
+            Composition =
+            {
+                Execute = _Lua [=[
+                    local scriptPath = app:MapPath("OpenPype:MenuScripts/openpype_menu.py")
+                    if bmd.fileexists(scriptPath) == false then
+                        print("[OpenPype Error] Can't run file: " .. scriptPath)
+                    else
+                        target:RunScript(scriptPath)
+                    end
+                ]=],
+            },
+        },
+    },
+    Action
+    {
+        ID = "OpenPype_Install_PySide2",
+        Category = "OpenPype",
+        Name = "Install PySide2",
+
+        Targets =
+        {
+            Composition =
+            {
+                Execute = _Lua [=[
+                    local scriptPath = app:MapPath("OpenPype:MenuScripts/install_pyside2.py")
+                    if bmd.fileexists(scriptPath) == false then
+                        print("[OpenPype Error] Can't run file: " .. scriptPath)
+                    else
+                        target:RunScript(scriptPath)
+                    end
+                ]=],
+            },
+        },
+    },
+    Menus
+    {
+        Target = "ChildFrame",
+
+        Before "Help"
+        {
+            Sub "OpenPype"
+            {
+                "OpenPype_Menu{}",
+                "_",
+                Sub "Admin" {
+                    "OpenPype_Install_PySide2{}"
+                }
+            }
+        },
+    },
+}

openpype/hosts/fusion/deploy/MenuScripts/README.md

@@ -0,0 +1,6 @@
+### OpenPype deploy MenuScripts
+
+Note that this `MenuScripts` is not an official Fusion folder.
+OpenPype only uses this folder in `{fusion}/deploy/` to trigger the OpenPype menu actions.
+
+They are used in the actions defined in `.fu` files in `{fusion}/deploy/Config`.

openpype/hosts/fusion/deploy/MenuScripts/install_pyside2.py

@@ -0,0 +1,29 @@
+# This is just a quick hack for users running Py3 locally but having no
+# Qt library installed
+import os
+import subprocess
+import importlib
+
+
+try:
+    from Qt import QtWidgets  # noqa: F401
+    from Qt import __binding__
+    print(f"Qt binding: {__binding__}")
+    mod = importlib.import_module(__binding__)
+    print(f"Qt path: {mod.__file__}")
+    print("Qt library found, nothing to do..")
+
+except ImportError:
+    print("Assuming no Qt library is installed..")
+    print('Installing PySide2 for Python 3.6: '
+          f'{os.environ["FUSION16_PYTHON36_HOME"]}')
+
+    # Get full path to python executable
+    exe = "python.exe" if os.name == 'nt' else "python"
+    python = os.path.join(os.environ["FUSION16_PYTHON36_HOME"], exe)
+    assert os.path.exists(python), f"Python doesn't exist: {python}"
+
+    # Do python -m pip install PySide2
+    args = [python, "-m", "pip", "install", "PySide2"]
+    print(f"Args: {args}")
+    subprocess.Popen(args)

openpype/hosts/fusion/deploy/MenuScripts/openpype_menu.py

@@ -9,6 +9,10 @@ from openpype.pipeline import (
 
 
 def main(env):
+    # This script working directory starts in Fusion application folder.
+    # However the contents of that folder can conflict with Qt library dlls
+    # so we make sure to move out of it to avoid DLL Load Failed errors.
+    os.chdir("..")
     from openpype.hosts.fusion import api
     from openpype.hosts.fusion.api import menu
 
@@ -20,6 +24,11 @@ def main(env):
 
     menu.launch_openpype_menu()
 
+    # Initiate a QTimer to check if Fusion is still alive every X interval
+    # If Fusion is not found - kill itself
+    # todo(roy): Implement timer that ensures UI doesn't remain when e.g.
+    #            Fusion closes down
+
 
 if __name__ == "__main__":
     result = main(os.environ)

openpype/hosts/fusion/deploy/fusion_shared.prefs

@@ -0,0 +1,19 @@
+{
+Locked = true,
+Global = {
+ Paths = {
+  Map = {
+   ["OpenPype:"] = "$(OPENPYPE_FUSION)/deploy",
+   ["Reactor:"] = "$(REACTOR)",
+
+   ["Config:"] = "UserPaths:Config;OpenPype:Config",
+   ["Scripts:"] = "UserPaths:Scripts;Reactor:System/Scripts;OpenPype:Scripts",
+   ["UserPaths:"] = "UserData:;AllData:;Fusion:;Reactor:Deploy"
+  },
+ },
+ Script = {
+			PythonVersion = 3,
+			Python3Forced = true
+		},
+    },
+}

openpype/hosts/fusion/hooks/pre_fusion_ocio_hook.py

@@ -0,0 +1,40 @@
+import os
+import platform
+
+from openpype.lib import PreLaunchHook, ApplicationLaunchFailed
+
+
+class FusionPreLaunchOCIO(PreLaunchHook):
+    """Set OCIO environment variable for Fusion"""
+    app_groups = ["fusion"]
+
+    def execute(self):
+        """Hook entry method."""
+
+        # get image io
+        project_settings = self.data["project_settings"]
+
+        # make sure anatomy settings are having flame key
+        imageio_fusion = project_settings.get("fusion", {}).get("imageio")
+        if not imageio_fusion:
+            raise ApplicationLaunchFailed((
+                "Anatomy project settings are missing `fusion` key. "
+                "Please make sure you remove project overrides on "
+                "Anatomy ImageIO")
+            )
+
+        ocio = imageio_fusion.get("ocio")
+        enabled = ocio.get("enabled", False)
+        if not enabled:
+            return
+
+        platform_key = platform.system().lower()
+        ocio_path = ocio["configFilePath"][platform_key]
+        if not ocio_path:
+            raise ApplicationLaunchFailed(
+                "Fusion OCIO is enabled in project settings but no OCIO config"
+                f"path is set for your current platform: {platform_key}"
+            )
+
+        self.log.info(f"Setting OCIO config path: {ocio_path}")
+        self.launch_context.env["OCIO"] = os.pathsep.join(ocio_path)

openpype/hosts/fusion/hooks/pre_fusion_setup.py

@@ -1,114 +1,61 @@
 import os
-import shutil
-
-import openpype.hosts.fusion
 from openpype.lib import PreLaunchHook, ApplicationLaunchFailed
+from openpype.hosts.fusion import FUSION_HOST_DIR
 
 
 class FusionPrelaunch(PreLaunchHook):
-    """
-    This hook will check if current workfile path has Fusion
-    project inside.
+    """Prepares OpenPype Fusion environment
+
+    Requires FUSION_PYTHON3_HOME to be defined in the environment for Fusion
+    to point at a valid Python 3 build for Fusion. That is Python 3.3-3.10
+    for Fusion 18 and Fusion 3.6 for Fusion 16 and 17.
+
+    This also sets FUSION16_MasterPrefs to apply the fusion master prefs
+    as set in openpype/hosts/fusion/deploy/fusion_shared.prefs to enable
+    the OpenPype menu and force Python 3 over Python 2.
+
     """
     app_groups = ["fusion"]
 
     def execute(self):
-        # making sure python 3.6 is installed at provided path
-        py36_dir = self.launch_context.env.get("PYTHON36")
-        if not py36_dir:
+        # making sure python 3 is installed at provided path
+        # Py 3.3-3.10 for Fusion 18+ or Py 3.6 for Fu 16-17
+        py3_var = "FUSION_PYTHON3_HOME"
+        fusion_python3_home = self.launch_context.env.get(py3_var, "")
+
+        self.log.info(f"Looking for Python 3 in: {fusion_python3_home}")
+        for path in fusion_python3_home.split(os.pathsep):
+            # Allow defining multiple paths to allow "fallback" to other
+            # path. But make to set only a single path as final variable.
+            py3_dir = os.path.normpath(path)
+            if os.path.isdir(py3_dir):
+                break
+        else:
             raise ApplicationLaunchFailed(
-                "Required environment variable \"PYTHON36\" is not set."
-                "\n\nFusion implementation requires to have"
-                " installed Python 3.6"
+                "Python 3 is not installed at the provided path.\n"
+                "Make sure the environment in fusion settings has "
+                "'FUSION_PYTHON3_HOME' set correctly and make sure "
+                "Python 3 is installed in the given path."
+                f"\n\nPYTHON36: {fusion_python3_home}"
             )
 
-        py36_dir = os.path.normpath(py36_dir)
-        if not os.path.isdir(py36_dir):
-            raise ApplicationLaunchFailed(
-                "Python 3.6 is not installed at the provided path.\n"
-                "Either make sure the environments in fusion settings has"
-                " 'PYTHON36' set corectly or make sure Python 3.6 is installed"
-                f" in the given path.\n\nPYTHON36: {py36_dir}"
-            )
-        self.log.info(f"Path to Fusion Python folder: '{py36_dir}'...")
-        self.launch_context.env["PYTHON36"] = py36_dir
+        self.log.info(f"Setting {py3_var}: '{py3_dir}'...")
+        self.launch_context.env[py3_var] = py3_dir
 
-        utility_dir = self.launch_context.env.get("FUSION_UTILITY_SCRIPTS_DIR")
-        if not utility_dir:
-            raise ApplicationLaunchFailed(
-                "Required Fusion utility script dir environment variable"
-                " \"FUSION_UTILITY_SCRIPTS_DIR\" is not set."
-            )
+        # Fusion 18+ requires FUSION_PYTHON3_HOME to also be on PATH
+        self.launch_context.env["PATH"] += ";" + py3_dir
 
-        # setting utility scripts dir for scripts syncing
-        utility_dir = os.path.normpath(utility_dir)
-        if not os.path.isdir(utility_dir):
-            raise ApplicationLaunchFailed(
-                "Fusion utility script dir does not exist. Either make sure "
-                "the environments in fusion settings has"
-                " 'FUSION_UTILITY_SCRIPTS_DIR' set correctly or reinstall "
-                f"Fusion.\n\nFUSION_UTILITY_SCRIPTS_DIR: '{utility_dir}'"
-            )
+        # Fusion 16 and 17 use FUSION16_PYTHON36_HOME instead of
+        # FUSION_PYTHON3_HOME and will only work with a Python 3.6 version
+        # TODO: Detect Fusion version to only set for specific Fusion build
+        self.launch_context.env["FUSION16_PYTHON36_HOME"] = py3_dir
 
-        self._sync_utility_scripts(self.launch_context.env)
-        self.log.info("Fusion Pype wrapper has been installed")
+        # Add our Fusion Master Prefs which is the only way to customize
+        # Fusion to define where it can read custom scripts and tools from
+        self.log.info(f"Setting OPENPYPE_FUSION: {FUSION_HOST_DIR}")
+        self.launch_context.env["OPENPYPE_FUSION"] = FUSION_HOST_DIR
 
-    def _sync_utility_scripts(self, env):
-        """ Synchronizing basic utlility scripts for resolve.
-
-        To be able to run scripts from inside `Fusion/Workspace/Scripts` menu
-        all scripts has to be accessible from defined folder.
-        """
-        if not env:
-            env = {k: v for k, v in os.environ.items()}
-
-        # initiate inputs
-        scripts = {}
-        us_env = env.get("FUSION_UTILITY_SCRIPTS_SOURCE_DIR")
-        us_dir = env.get("FUSION_UTILITY_SCRIPTS_DIR", "")
-        us_paths = [os.path.join(
-            os.path.dirname(os.path.abspath(openpype.hosts.fusion.__file__)),
-            "utility_scripts"
-        )]
-
-        # collect script dirs
-        if us_env:
-            self.log.info(f"Utility Scripts Env: `{us_env}`")
-            us_paths = us_env.split(
-                os.pathsep) + us_paths
-
-        # collect scripts from dirs
-        for path in us_paths:
-            scripts.update({path: os.listdir(path)})
-
-        self.log.info(f"Utility Scripts Dir: `{us_paths}`")
-        self.log.info(f"Utility Scripts: `{scripts}`")
-
-        # make sure no script file is in folder
-        if next((s for s in os.listdir(us_dir)), None):
-            for s in os.listdir(us_dir):
-                path = os.path.normpath(
-                    os.path.join(us_dir, s))
-                self.log.info(f"Removing `{path}`...")
-
-                # remove file or directory if not in our folders
-                if not os.path.isdir(path):
-                    os.remove(path)
-                else:
-                    shutil.rmtree(path)
-
-        # copy scripts into Resolve's utility scripts dir
-        for d, sl in scripts.items():
-            # directory and scripts list
-            for s in sl:
-                # script in script list
-                src = os.path.normpath(os.path.join(d, s))
-                dst = os.path.normpath(os.path.join(us_dir, s))
-
-                self.log.info(f"Copying `{src}` to `{dst}`...")
-
-                # copy file or directory from our folders to fusion's folder
-                if not os.path.isdir(src):
-                    shutil.copy2(src, dst)
-                else:
-                    shutil.copytree(src, dst)
+        pref_var = "FUSION16_MasterPrefs"   # used by Fusion 16, 17 and 18
+        prefs = os.path.join(FUSION_HOST_DIR, "deploy", "fusion_shared.prefs")
+        self.log.info(f"Setting {pref_var}: {prefs}")
+        self.launch_context.env[pref_var] = prefs

openpype/hosts/fusion/plugins/create/create_exr_saver.py

@@ -1,6 +1,9 @@
 import os
 
-from openpype.pipeline import LegacyCreator
+from openpype.pipeline import (
+    LegacyCreator,
+    legacy_io
+)
 from openpype.hosts.fusion.api import (
     get_current_comp,
     comp_lock_and_undo_chunk
@@ -21,12 +24,9 @@ class CreateOpenEXRSaver(LegacyCreator):
 
         comp = get_current_comp()
 
-        # todo: improve method of getting current environment
-        # todo: pref avalon.Session over os.environ
+        workdir = os.path.normpath(legacy_io.Session["AVALON_WORKDIR"])
 
-        workdir = os.path.normpath(os.environ["AVALON_WORKDIR"])
-
-        filename = "{}..tiff".format(self.name)
+        filename = "{}..exr".format(self.name)
         filepath = os.path.join(workdir, "render", filename)
 
         with comp_lock_and_undo_chunk(comp):
@@ -39,10 +39,10 @@ class CreateOpenEXRSaver(LegacyCreator):
             saver["Clip"] = filepath
             saver["OutputFormat"] = file_format
 
-            # # # Set standard TIFF settings
+            # Check file format settings are available
             if saver[file_format] is None:
-                raise RuntimeError("File format is not set to TiffFormat, "
-                                   "this is a bug")
+                raise RuntimeError("File format is not set to {}, "
+                                   "this is a bug".format(file_format))
 
             # Set file format attributes
             saver[file_format]["Depth"] = 1  # int8 | int16 | float32 | other

openpype/hosts/fusion/plugins/load/load_sequence.py

@@ -101,6 +101,9 @@ def loader_shift(loader, frame, relative=True):
     else:
         shift = frame - old_in
 
+    if not shift:
+        return 0
+
     # Shifting global in will try to automatically compensate for the change
     # in the "ClipTimeStart" and "HoldFirstFrame" inputs, so we preserve those
     # input values to "just shift" the clip
@@ -149,9 +152,8 @@ class FusionLoadSequence(load.LoaderPlugin):
             tool["Clip"] = path
 
             # Set global in point to start frame (if in version.data)
-            start = context["version"]["data"].get("frameStart", None)
-            if start is not None:
-                loader_shift(tool, start, relative=False)
+            start = self._get_start(context["version"], tool)
+            loader_shift(tool, start, relative=False)
 
             imprint_container(tool,
                               name=name,
@@ -214,12 +216,7 @@ class FusionLoadSequence(load.LoaderPlugin):
         # Get start frame from version data
         project_name = legacy_io.active_project()
         version = get_version_by_id(project_name, representation["parent"])
-        start = version["data"].get("frameStart")
-        if start is None:
-            self.log.warning("Missing start frame for updated version"
-                             "assuming starts at frame 0 for: "
-                             "{} ({})".format(tool.Name, representation))
-            start = 0
+        start = self._get_start(version, tool)
 
         with comp_lock_and_undo_chunk(comp, "Update Loader"):
 
@@ -256,3 +253,27 @@ class FusionLoadSequence(load.LoaderPlugin):
         """Get first file in representation root"""
         files = sorted(os.listdir(root))
         return os.path.join(root, files[0])
+
+    def _get_start(self, version_doc, tool):
+        """Return real start frame of published files (incl. handles)"""
+        data = version_doc["data"]
+
+        # Get start frame directly with handle if it's in data
+        start = data.get("frameStartHandle")
+        if start is not None:
+            return start
+
+        # Get frame start without handles
+        start = data.get("frameStart")
+        if start is None:
+            self.log.warning("Missing start frame for version "
+                             "assuming starts at frame 0 for: "
+                             "{}".format(tool.Name))
+            return 0
+
+        # Use `handleStart` if the data is available
+        handle_start = data.get("handleStart")
+        if handle_start:
+            start -= handle_start
+
+        return start

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

@@ -4,19 +4,21 @@ import pyblish.api
 
 
 def get_comp_render_range(comp):
-    """Return comp's start and end render range."""
+    """Return comp's start-end render range and global start-end range."""
     comp_attrs = comp.GetAttrs()
     start = comp_attrs["COMPN_RenderStart"]
     end = comp_attrs["COMPN_RenderEnd"]
+    global_start = comp_attrs["COMPN_GlobalStart"]
+    global_end = comp_attrs["COMPN_GlobalEnd"]
 
     # Whenever render ranges are undefined fall back
     # to the comp's global start and end
     if start == -1000000000:
-        start = comp_attrs["COMPN_GlobalEnd"]
+        start = global_start
     if end == -1000000000:
-        end = comp_attrs["COMPN_GlobalStart"]
+        end = global_end
 
-    return start, end
+    return start, end, global_start, global_end
 
 
 class CollectInstances(pyblish.api.ContextPlugin):
@@ -42,9 +44,11 @@ class CollectInstances(pyblish.api.ContextPlugin):
         tools = comp.GetToolList(False).values()
         savers = [tool for tool in tools if tool.ID == "Saver"]
 
-        start, end = get_comp_render_range(comp)
+        start, end, global_start, global_end = get_comp_render_range(comp)
         context.data["frameStart"] = int(start)
         context.data["frameEnd"] = int(end)
+        context.data["frameStartHandle"] = int(global_start)
+        context.data["frameEndHandle"] = int(global_end)
 
         for tool in savers:
             path = tool["Clip"][comp.TIME_UNDEFINED]
@@ -78,8 +82,10 @@ class CollectInstances(pyblish.api.ContextPlugin):
                 "label": label,
                 "frameStart": context.data["frameStart"],
                 "frameEnd": context.data["frameEnd"],
+                "frameStartHandle": context.data["frameStartHandle"],
+                "frameEndHandle": context.data["frameStartHandle"],
                 "fps": context.data["fps"],
-                "families": ["render", "review", "ftrack"],
+                "families": ["render", "review"],
                 "family": "render",
                 "active": active,
                 "publish": active   # backwards compatibility

openpype/hosts/fusion/plugins/publish/render_local.py

@@ -20,6 +20,8 @@ class Fusionlocal(pyblish.api.InstancePlugin):
 
     def process(self, instance):
 
+        # This plug-in runs only once and thus assumes all instances
+        # currently will render the same frame range
         context = instance.context
         key = "__hasRun{}".format(self.__class__.__name__)
         if context.data.get(key, False):
@@ -28,8 +30,8 @@ class Fusionlocal(pyblish.api.InstancePlugin):
             context.data[key] = True
 
         current_comp = context.data["currentComp"]
-        frame_start = current_comp.GetAttrs("COMPN_RenderStart")
-        frame_end = current_comp.GetAttrs("COMPN_RenderEnd")
+        frame_start = context.data["frameStartHandle"]
+        frame_end = context.data["frameEndHandle"]
         path = instance.data["path"]
         output_dir = instance.data["outputDir"]
 
@@ -40,7 +42,11 @@ class Fusionlocal(pyblish.api.InstancePlugin):
         self.log.info("End frame: {}".format(frame_end))
 
         with comp_lock_and_undo_chunk(current_comp):
-            result = current_comp.Render()
+            result = current_comp.Render({
+                "Start": frame_start,
+                "End": frame_end,
+                "Wait": True
+            })
 
         if "representations" not in instance.data:
             instance.data["representations"] = []

openpype/hosts/fusion/scripts/fusion_switch_shot.py

@@ -1,284 +0,0 @@
-import os
-import re
-import sys
-import logging
-
-from openpype.client import (
-    get_asset_by_name,
-    get_versions,
-)
-from openpype.pipeline import (
-    legacy_io,
-    install_host,
-    registered_host,
-)
-from openpype.lib import version_up
-from openpype.hosts.fusion import api
-from openpype.hosts.fusion.api import lib
-from openpype.pipeline.context_tools import get_workdir_from_session
-
-log = logging.getLogger("Update Slap Comp")
-
-
-def _format_version_folder(folder):
-    """Format a version folder based on the filepath
-
-    Assumption here is made that, if the path does not exists the folder
-    will be "v001"
-
-    Args:
-        folder: file path to a folder
-
-    Returns:
-        str: new version folder name
-    """
-
-    new_version = 1
-    if os.path.isdir(folder):
-        re_version = re.compile(r"v\d+$")
-        versions = [i for i in os.listdir(folder) if os.path.isdir(i)
-                    and re_version.match(i)]
-        if versions:
-            # ensure the "v" is not included
-            new_version = int(max(versions)[1:]) + 1
-
-    version_folder = "v{:03d}".format(new_version)
-
-    return version_folder
-
-
-def _get_fusion_instance():
-    fusion = getattr(sys.modules["__main__"], "fusion", None)
-    if fusion is None:
-        try:
-            # Support for FuScript.exe, BlackmagicFusion module for py2 only
-            import BlackmagicFusion as bmf
-            fusion = bmf.scriptapp("Fusion")
-        except ImportError:
-            raise RuntimeError("Could not find a Fusion instance")
-    return fusion
-
-
-def _format_filepath(session):
-
-    project = session["AVALON_PROJECT"]
-    asset = session["AVALON_ASSET"]
-
-    # Save updated slap comp
-    work_path = get_workdir_from_session(session)
-    walk_to_dir = os.path.join(work_path, "scenes", "slapcomp")
-    slapcomp_dir = os.path.abspath(walk_to_dir)
-
-    # Ensure destination exists
-    if not os.path.isdir(slapcomp_dir):
-        log.warning("Folder did not exist, creating folder structure")
-        os.makedirs(slapcomp_dir)
-
-    # Compute output path
-    new_filename = "{}_{}_slapcomp_v001.comp".format(project, asset)
-    new_filepath = os.path.join(slapcomp_dir, new_filename)
-
-    # Create new unique filepath
-    if os.path.exists(new_filepath):
-        new_filepath = version_up(new_filepath)
-
-    return new_filepath
-
-
-def _update_savers(comp, session):
-    """Update all savers of the current comp to ensure the output is correct
-
-    This will refactor the Saver file outputs to the renders of the new session
-    that is provided.
-
-    In the case the original saver path had a path set relative to a /fusion/
-    folder then that relative path will be matched with the exception of all
-    "version" (e.g. v010) references will be reset to v001. Otherwise only a
-    version folder will be computed in the new session's work "render" folder
-    to dump the files in and keeping the original filenames.
-
-    Args:
-        comp (object): current comp instance
-        session (dict): the current Avalon session
-
-    Returns:
-         None
-    """
-
-    new_work = get_workdir_from_session(session)
-    renders = os.path.join(new_work, "renders")
-    version_folder = _format_version_folder(renders)
-    renders_version = os.path.join(renders, version_folder)
-
-    comp.Print("New renders to: %s\n" % renders)
-
-    with api.comp_lock_and_undo_chunk(comp):
-        savers = comp.GetToolList(False, "Saver").values()
-        for saver in savers:
-            filepath = saver.GetAttrs("TOOLST_Clip_Name")[1.0]
-
-            # Get old relative path to the "fusion" app folder so we can apply
-            # the same relative path afterwards. If not found fall back to
-            # using just a version folder with the filename in it.
-            # todo: can we make this less magical?
-            relpath = filepath.replace("\\", "/").rsplit("/fusion/", 1)[-1]
-
-            if os.path.isabs(relpath):
-                # If not relative to a "/fusion/" folder then just use filename
-                filename = os.path.basename(filepath)
-                log.warning("Can't parse relative path, refactoring to only"
-                            "filename in a version folder: %s" % filename)
-                new_path = os.path.join(renders_version, filename)
-
-            else:
-                # Else reuse the relative path
-                # Reset version in folder and filename in the relative path
-                # to v001. The version should be is only detected when prefixed
-                # with either `_v` (underscore) or `/v` (folder)
-                version_pattern = r"(/|_)v[0-9]+"
-                if re.search(version_pattern, relpath):
-                    new_relpath = re.sub(version_pattern,
-                                         r"\1v001",
-                                         relpath)
-                    log.info("Resetting version folders to v001: "
-                             "%s -> %s" % (relpath, new_relpath))
-                    relpath = new_relpath
-
-                new_path = os.path.join(new_work, relpath)
-
-            saver["Clip"] = new_path
-
-
-def update_frame_range(comp, representations):
-    """Update the frame range of the comp and render length
-
-    The start and end frame are based on the lowest start frame and the highest
-    end frame
-
-    Args:
-        comp (object): current focused comp
-        representations (list) collection of dicts
-
-    Returns:
-        None
-
-    """
-
-    project_name = legacy_io.active_project()
-    version_ids = {r["parent"] for r in representations}
-    versions = list(get_versions(project_name, version_ids))
-
-    versions = [v for v in versions
-                if v["data"].get("frameStart", None) is not None]
-
-    if not versions:
-        log.warning("No versions loaded to match frame range to.\n")
-        return
-
-    start = min(v["data"]["frameStart"] for v in versions)
-    end = max(v["data"]["frameEnd"] for v in versions)
-
-    lib.update_frame_range(start, end, comp=comp)
-
-
-def switch(asset_name, filepath=None, new=True):
-    """Switch the current containers of the file to the other asset (shot)
-
-    Args:
-        filepath (str): file path of the comp file
-        asset_name (str): name of the asset (shot)
-        new (bool): Save updated comp under a different name
-
-    Returns:
-        comp path (str): new filepath of the updated comp
-
-    """
-
-    # If filepath provided, ensure it is valid absolute path
-    if filepath is not None:
-        if not os.path.isabs(filepath):
-            filepath = os.path.abspath(filepath)
-
-        assert os.path.exists(filepath), "%s must exist " % filepath
-
-    # Assert asset name exists
-    # It is better to do this here then to wait till switch_shot does it
-    project_name = legacy_io.active_project()
-    asset = get_asset_by_name(project_name, asset_name)
-    assert asset, "Could not find '%s' in the database" % asset_name
-
-    # Go to comp
-    if not filepath:
-        current_comp = api.get_current_comp()
-        assert current_comp is not None, "Could not find current comp"
-    else:
-        fusion = _get_fusion_instance()
-        current_comp = fusion.LoadComp(filepath, quiet=True)
-        assert current_comp is not None, (
-            "Fusion could not load '{}'").format(filepath)
-
-    host = registered_host()
-    containers = list(host.ls())
-    assert containers, "Nothing to update"
-
-    representations = []
-    for container in containers:
-        try:
-            representation = lib.switch_item(
-                container,
-                asset_name=asset_name)
-            representations.append(representation)
-        except Exception as e:
-            current_comp.Print("Error in switching! %s\n" % e.message)
-
-    message = "Switched %i Loaders of the %i\n" % (len(representations),
-                                                   len(containers))
-    current_comp.Print(message)
-
-    # Build the session to switch to
-    switch_to_session = legacy_io.Session.copy()
-    switch_to_session["AVALON_ASSET"] = asset['name']
-
-    if new:
-        comp_path = _format_filepath(switch_to_session)
-
-        # Update savers output based on new session
-        _update_savers(current_comp, switch_to_session)
-    else:
-        comp_path = version_up(filepath)
-
-    current_comp.Print(comp_path)
-
-    current_comp.Print("\nUpdating frame range")
-    update_frame_range(current_comp, representations)
-
-    current_comp.Save(comp_path)
-
-    return comp_path
-
-
-if __name__ == '__main__':
-
-    # QUESTION: can we convert this to gui rather then standalone script?
-    # TODO: convert to gui tool
-    import argparse
-
-    parser = argparse.ArgumentParser(description="Switch to a shot within an"
-                                                 "existing comp file")
-
-    parser.add_argument("--file_path",
-                        type=str,
-                        default=True,
-                        help="File path of the comp to use")
-
-    parser.add_argument("--asset_name",
-                        type=str,
-                        default=True,
-                        help="Name of the asset (shot) to switch")
-
-    args, unknown = parser.parse_args()
-
-    install_host(api)
-    switch(args.asset_name, args.file_path)
-
-    sys.exit(0)

openpype/hosts/harmony/plugins/publish/extract_palette.py

@@ -6,10 +6,10 @@ import csv
 from PIL import Image, ImageDraw, ImageFont
 
 import openpype.hosts.harmony.api as harmony
-import openpype.api
+from openpype.pipeline import publish
 
 
-class ExtractPalette(openpype.api.Extractor):
+class ExtractPalette(publish.Extractor):
     """Extract palette."""
 
     label = "Extract Palette"

openpype/hosts/harmony/plugins/publish/extract_template.py

@@ -3,12 +3,11 @@
 import os
 import shutil
 
-import openpype.api
+from openpype.pipeline import publish
 import openpype.hosts.harmony.api as harmony
-import openpype.hosts.harmony
 
 
-class ExtractTemplate(openpype.api.Extractor):
+class ExtractTemplate(publish.Extractor):
     """Extract the connected nodes to the composite instance."""
 
     label = "Extract Template"
@@ -50,7 +49,7 @@ class ExtractTemplate(openpype.api.Extractor):
             dependencies.remove(instance.data["setMembers"][0])
 
         # Export template.
-        openpype.hosts.harmony.api.export_template(
+        harmony.export_template(
             unique_backdrops, dependencies, filepath
         )
 

openpype/hosts/harmony/plugins/publish/extract_workfile.py

@@ -4,10 +4,10 @@ import os
 import shutil
 from zipfile import ZipFile
 
-import openpype.api
+from openpype.pipeline import publish
 
 
-class ExtractWorkfile(openpype.api.Extractor):
+class ExtractWorkfile(publish.Extractor):
     """Extract and zip complete workfile folder into zip."""
 
     label = "Extract Workfile"

openpype/hosts/hiero/api/lib.py

@@ -13,14 +13,10 @@ import hiero
 
 from Qt import QtWidgets
 
-from openpype.client import (
-    get_project,
-    get_versions,
-    get_last_versions,
-    get_representations,
-)
+from openpype.client import get_project
 from openpype.settings import get_anatomy_settings
 from openpype.pipeline import legacy_io, Anatomy
+from openpype.pipeline.load import filter_containers
 from openpype.lib import Logger
 from . import tags
 
@@ -1055,6 +1051,10 @@ def sync_clip_name_to_data_asset(track_items_list):
             print("asset was changed in clip: {}".format(ti_name))
 
 
+def set_track_color(track_item, color):
+    track_item.source().binItem().setColor(color)
+
+
 def check_inventory_versions(track_items=None):
     """
     Actual version color idetifier of Loaded containers
@@ -1066,68 +1066,29 @@ def check_inventory_versions(track_items=None):
     """
     from . import parse_container
 
-    track_item = track_items or get_track_items()
+    track_items = track_items or get_track_items()
     # presets
     clip_color_last = "green"
     clip_color = "red"
 
-    item_with_repre_id = []
-    repre_ids = set()
+    containers = []
     # Find all containers and collect it's node and representation ids
-    for track_item in track_item:
+    for track_item in track_items:
         container = parse_container(track_item)
         if container:
-            repre_id = container["representation"]
-            repre_ids.add(repre_id)
-            item_with_repre_id.append((track_item, repre_id))
+            containers.append(container)
 
     # Skip if nothing was found
-    if not repre_ids:
+    if not containers:
         return
 
     project_name = legacy_io.active_project()
-    # Find representations based on found containers
-    repre_docs = get_representations(
-        project_name,
-        repre_ids=repre_ids,
-        fields=["_id", "parent"]
-    )
-    # Store representations by id and collect version ids
-    repre_docs_by_id = {}
-    version_ids = set()
-    for repre_doc in repre_docs:
-        # Use stringed representation id to match value in containers
-        repre_id = str(repre_doc["_id"])
-        repre_docs_by_id[repre_id] = repre_doc
-        version_ids.add(repre_doc["parent"])
+    filter_result = filter_containers(containers, project_name)
+    for container in filter_result.latest:
+        set_track_color(container["_track_item"], clip_color)
 
-    version_docs = get_versions(
-        project_name, version_ids, fields=["_id", "name", "parent"]
-    )
-    # Store versions by id and collect subset ids
-    version_docs_by_id = {}
-    subset_ids = set()
-    for version_doc in version_docs:
-        version_docs_by_id[version_doc["_id"]] = version_doc
-        subset_ids.add(version_doc["parent"])
-
-    # Query last versions based on subset ids
-    last_versions_by_subset_id = get_last_versions(
-        project_name, subset_ids=subset_ids, fields=["_id", "parent"]
-    )
-
-    for item in item_with_repre_id:
-        # Some python versions of nuke can't unfold tuple in for loop
-        track_item, repre_id = item
-
-        repre_doc = repre_docs_by_id[repre_id]
-        version_doc = version_docs_by_id[repre_doc["parent"]]
-        last_version_doc = last_versions_by_subset_id[version_doc["parent"]]
-        # Check if last version is same as current version
-        if version_doc["_id"] == last_version_doc["_id"]:
-            track_item.source().binItem().setColor(clip_color_last)
-        else:
-            track_item.source().binItem().setColor(clip_color)
+    for container in filter_result.outdated:
+        set_track_color(container["_track_item"], clip_color_last)
 
 
 def selection_changed_timeline(event):

openpype/hosts/houdini/plugins/publish/collect_remote_publish.py

@@ -1,7 +1,7 @@
 import pyblish.api
-import openpype.api
 
 import hou
+from openpype.pipeline.publish import RepairAction
 from openpype.hosts.houdini.api import lib
 
 
@@ -13,7 +13,7 @@ class CollectRemotePublishSettings(pyblish.api.ContextPlugin):
     hosts = ["houdini"]
     targets = ["deadline"]
     label = "Remote Publish Submission Settings"
-    actions = [openpype.api.RepairAction]
+    actions = [RepairAction]
 
     def process(self, context):
 

openpype/hosts/houdini/plugins/publish/extract_alembic.py

@@ -1,11 +1,12 @@
 import os
 
 import pyblish.api
-import openpype.api
+
+from openpype.pipeline import publish
 from openpype.hosts.houdini.api.lib import render_rop
 
 
-class ExtractAlembic(openpype.api.Extractor):
+class ExtractAlembic(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder
     label = "Extract Alembic"

openpype/hosts/houdini/plugins/publish/extract_ass.py

@@ -1,11 +1,12 @@
 import os
 
 import pyblish.api
-import openpype.api
+
+from openpype.pipeline import publish
 from openpype.hosts.houdini.api.lib import render_rop
 
 
-class ExtractAss(openpype.api.Extractor):
+class ExtractAss(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder + 0.1
     label = "Extract Ass"

openpype/hosts/houdini/plugins/publish/extract_composite.py

@@ -1,12 +1,12 @@
 import os
 
 import pyblish.api
-import openpype.api
 
+from openpype.pipeline import publish
 from openpype.hosts.houdini.api.lib import render_rop
 
 
-class ExtractComposite(openpype.api.Extractor):
+class ExtractComposite(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder
     label = "Extract Composite (Image Sequence)"

openpype/hosts/houdini/plugins/publish/extract_hda.py

@@ -4,10 +4,11 @@ import os
 from pprint import pformat
 
 import pyblish.api
-import openpype.api
+
+from openpype.pipeline import publish
 
 
-class ExtractHDA(openpype.api.Extractor):
+class ExtractHDA(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder
     label = "Extract HDA"

openpype/hosts/houdini/plugins/publish/extract_redshift_proxy.py

@@ -1,11 +1,12 @@
 import os
 
 import pyblish.api
-import openpype.api
+
+from openpype.pipeline import publish
 from openpype.hosts.houdini.api.lib import render_rop
 
 
-class ExtractRedshiftProxy(openpype.api.Extractor):
+class ExtractRedshiftProxy(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder + 0.1
     label = "Extract Redshift Proxy"

openpype/hosts/houdini/plugins/publish/extract_usd.py

@@ -1,11 +1,12 @@
 import os
 
 import pyblish.api
-import openpype.api
+
+from openpype.pipeline import publish
 from openpype.hosts.houdini.api.lib import render_rop
 
 
-class ExtractUSD(openpype.api.Extractor):
+class ExtractUSD(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder
     label = "Extract USD"

openpype/hosts/houdini/plugins/publish/extract_usd_layered.py

@@ -5,7 +5,6 @@ import sys
 from collections import deque
 
 import pyblish.api
-import openpype.api
 
 from openpype.client import (
     get_asset_by_name,
@@ -16,6 +15,7 @@ from openpype.client import (
 from openpype.pipeline import (
     get_representation_path,
     legacy_io,
+    publish,
 )
 import openpype.hosts.houdini.api.usd as hou_usdlib
 from openpype.hosts.houdini.api.lib import render_rop
@@ -160,7 +160,7 @@ def parm_values(overrides):
                 parm.set(value)
 
 
-class ExtractUSDLayered(openpype.api.Extractor):
+class ExtractUSDLayered(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder
     label = "Extract Layered USD"

openpype/hosts/houdini/plugins/publish/extract_vdb_cache.py

@@ -1,11 +1,12 @@
 import os
 
 import pyblish.api
-import openpype.api
+
+from openpype.pipeline import publish
 from openpype.hosts.houdini.api.lib import render_rop
 
 
-class ExtractVDBCache(openpype.api.Extractor):
+class ExtractVDBCache(publish.Extractor):
 
     order = pyblish.api.ExtractorOrder + 0.1
     label = "Extract VDB Cache"

openpype/hosts/maya/plugins/publish/validate_rendersettings.py

@@ -13,6 +13,12 @@ from openpype.pipeline.publish import (
 from openpype.hosts.maya.api import lib
 
 
+def get_redshift_image_format_labels():
+    """Return nice labels for Redshift image formats."""
+    var = "$g_redshiftImageFormatLabels"
+    return mel.eval("{0}={0}".format(var))
+
+
 class ValidateRenderSettings(pyblish.api.InstancePlugin):
     """Validates the global render settings
 
@@ -105,8 +111,9 @@ class ValidateRenderSettings(pyblish.api.InstancePlugin):
 
         # Get the node attributes for current renderer
         attrs = lib.RENDER_ATTRS.get(renderer, lib.RENDER_ATTRS['default'])
+        # Prefix attribute can return None when a value was never set
         prefix = lib.get_attr_in_layer(cls.ImagePrefixes[renderer],
-                                       layer=layer)
+                                       layer=layer) or ""
         padding = lib.get_attr_in_layer("{node}.{padding}".format(**attrs),
                                         layer=layer)
 
@@ -183,18 +190,22 @@ class ValidateRenderSettings(pyblish.api.InstancePlugin):
                         redshift_AOV_prefix
                     ))
                     invalid = True
-                # get aov format
-                aov_ext = cmds.getAttr(
-                    "{}.fileFormat".format(aov), asString=True)
 
-                default_ext = cmds.getAttr(
-                    "redshiftOptions.imageFormat", asString=True)
+                # check aov file format
+                aov_ext = cmds.getAttr("{}.fileFormat".format(aov))
+                default_ext = cmds.getAttr("redshiftOptions.imageFormat")
+                aov_type = cmds.getAttr("{}.aovType".format(aov))
+                if aov_type == "Cryptomatte":
+                    # redshift Cryptomatte AOV always uses "Cryptomatte (EXR)"
+                    # so we ignore validating file format for it.
+                    pass
 
-                if default_ext != aov_ext:
-                    cls.log.error(("AOV file format is not the same "
-                                   "as the one set globally "
-                                   "{} != {}").format(default_ext,
-                                                      aov_ext))
+                elif default_ext != aov_ext:
+                    labels = get_redshift_image_format_labels()
+                    cls.log.error(
+                        "AOV file format {} does not match global file format "
+                        "{}".format(labels[aov_ext], labels[default_ext])
+                    )
                     invalid = True
 
         if renderer == "renderman":
@@ -302,6 +313,9 @@ class ValidateRenderSettings(pyblish.api.InstancePlugin):
             default = lib.RENDER_ATTRS['default']
             render_attrs = lib.RENDER_ATTRS.get(renderer, default)
 
+            # Repair animation must be enabled
+            cmds.setAttr("defaultRenderGlobals.animation", True)
+
             # Repair prefix
             if renderer != "renderman":
                 node = render_attrs["node"]
@@ -334,8 +348,7 @@ class ValidateRenderSettings(pyblish.api.InstancePlugin):
                 cmds.optionMenuGrp("vrayRenderElementSeparator",
                                    v=instance.data.get("aovSeparator", "_"))
                 cmds.setAttr(
-                    "{}.fileNameRenderElementSeparator".format(
-                        node),
+                    "{}.fileNameRenderElementSeparator".format(node),
                     instance.data.get("aovSeparator", "_"),
                     type="string"
                 )

openpype/hosts/photoshop/plugins/publish/collect_review.py

@@ -25,6 +25,8 @@ class CollectReview(pyblish.api.ContextPlugin):
     hosts = ["photoshop"]
     order = pyblish.api.CollectorOrder + 0.1
 
+    publish = True
+
     def process(self, context):
         family = "review"
         subset = get_subset_name(
@@ -45,5 +47,6 @@ class CollectReview(pyblish.api.ContextPlugin):
             "family": family,
             "families": [],
             "representations": [],
-            "asset": os.environ["AVALON_ASSET"]
+            "asset": os.environ["AVALON_ASSET"],
+            "publish": self.publish
         })

openpype/hosts/tvpaint/lib.py

@@ -646,9 +646,6 @@ def rename_filepaths_by_frame_start(
     filepaths_by_frame, range_start, range_end, new_frame_start
 ):
     """Change frames in filenames of finished images to new frame start."""
-    # Skip if source first frame is same as destination first frame
-    if range_start == new_frame_start:
-        return
 
     # Calculate frame end
     new_frame_end = range_end + (new_frame_start - range_start)
@@ -669,14 +666,17 @@ def rename_filepaths_by_frame_start(
         source_range = range(range_start, range_end + 1)
         output_range = range(new_frame_start, new_frame_end + 1)
 
+    # Skip if source first frame is same as destination first frame
     new_dst_filepaths = {}
     for src_frame, dst_frame in zip(source_range, output_range):
-        src_filepath = filepaths_by_frame[src_frame]
-        src_dirpath = os.path.dirname(src_filepath)
+        src_filepath = os.path.normpath(filepaths_by_frame[src_frame])
+        dirpath, src_filename = os.path.split(src_filepath)
         dst_filename = filename_template.format(frame=dst_frame)
-        dst_filepath = os.path.join(src_dirpath, dst_filename)
+        dst_filepath = os.path.join(dirpath, dst_filename)
 
-        os.rename(src_filepath, dst_filepath)
+        if src_filename != dst_filename:
+            os.rename(src_filepath, dst_filepath)
 
         new_dst_filepaths[dst_frame] = dst_filepath
+
     return new_dst_filepaths

openpype/lib/transcoding.py

@@ -139,7 +139,7 @@ def convert_value_by_type_name(value_type, value, logger=None):
         return float(value)
 
     # Vectors will probably have more types
-    if value_type == "vec2f":
+    if value_type in ("vec2f", "float2"):
         return [float(item) for item in value.split(",")]
 
     # Matrix should be always have square size of element 3x3, 4x4
@@ -204,8 +204,8 @@ def convert_value_by_type_name(value_type, value, logger=None):
             )
         return output
 
-    logger.info((
-        "MISSING IMPLEMENTATION:"
+    logger.debug((
+        "Dev note (missing implementation):"
         " Unknown attrib type \"{}\". Value: {}"
     ).format(value_type, value))
     return value
@@ -263,8 +263,8 @@ def parse_oiio_xml_output(xml_string, logger=None):
         # - feel free to add more tags
         else:
             value = child.text
-            logger.info((
-                "MISSING IMPLEMENTATION:"
+            logger.debug((
+                "Dev note (missing implementation):"
                 " Unknown tag \"{}\". Value \"{}\""
             ).format(tag_name, value))
 

openpype/modules/deadline/repository/custom/plugins/OpenPypeTileAssembler/OpenPypeTileAssembler.py

@@ -56,7 +56,7 @@ def convert_value_by_type_name(value_type, value):
         return float(value)
 
     # Vectors will probably have more types
-    if value_type == "vec2f":
+    if value_type in ("vec2f", "float2"):
         return [float(item) for item in value.split(",")]
 
     # Matrix should be always have square size of element 3x3, 4x4
@@ -127,7 +127,7 @@ def convert_value_by_type_name(value_type, value):
         return output
 
     print((
-        "MISSING IMPLEMENTATION:"
+        "Dev note (missing implementation):"
         " Unknown attrib type \"{}\". Value: {}"
     ).format(value_type, value))
     return value
@@ -183,7 +183,7 @@ def parse_oiio_xml_output(xml_string):
         else:
             value = child.text
             print((
-                "MISSING IMPLEMENTATION:"
+                "Dev note (missing implementation):"
                 " Unknown tag \"{}\". Value \"{}\""
             ).format(tag_name, value))
 

openpype/pipeline/load/utils.py

@@ -37,7 +37,7 @@ log = logging.getLogger(__name__)
 
 ContainersFilterResult = collections.namedtuple(
     "ContainersFilterResult",
-    ["latest", "outdated", "not_foud", "invalid"]
+    ["latest", "outdated", "not_found", "invalid"]
 )
 
 
@@ -808,7 +808,7 @@ def filter_containers(containers, project_name):
 
     Categories are 'latest', 'outdated', 'invalid' and 'not_found'.
     The 'lastest' containers are from last version, 'outdated' are not,
-    'invalid' are invalid containers (invalid content) and 'not_foud' has
+    'invalid' are invalid containers (invalid content) and 'not_found' has
     some missing entity in database.
 
     Args:

openpype/plugins/publish/collect_otio_frame_ranges.py

@@ -10,6 +10,7 @@ import opentimelineio as otio
 import pyblish.api
 from pprint import pformat
 from openpype.pipeline.editorial import (
+    get_media_range_with_retimes,
     otio_range_to_frame_range,
     otio_range_with_handles
 )
@@ -29,7 +30,7 @@ class CollectOtioFrameRanges(pyblish.api.InstancePlugin):
         # get basic variables
         otio_clip = instance.data["otioClip"]
         workfile_start = instance.data["workfileFrameStart"]
-        workfile_source_duration = instance.data.get("notRetimedFramerange")
+        workfile_source_duration = instance.data.get("shotDurationFromSource")
 
         # get ranges
         otio_tl_range = otio_clip.range_in_parent()
@@ -57,8 +58,15 @@ class CollectOtioFrameRanges(pyblish.api.InstancePlugin):
 
         # in case of retimed clip and frame range should not be retimed
         if workfile_source_duration:
-            frame_end = frame_start + otio.opentime.to_frames(
-                otio_src_range.duration, otio_src_range.duration.rate) - 1
+            # get available range trimmed with processed retimes
+            retimed_attributes = get_media_range_with_retimes(
+                otio_clip, 0, 0)
+            self.log.debug(
+                ">> retimed_attributes: {}".format(retimed_attributes))
+            media_in = int(retimed_attributes["mediaIn"])
+            media_out = int(retimed_attributes["mediaOut"])
+            frame_end = frame_start + (media_out - media_in) + 1
+            self.log.debug(frame_end)
 
         data = {
             "frameStart": frame_start,

openpype/pype_commands.py

@@ -218,7 +218,7 @@ class PypeCommands:
             RuntimeError: When there is no path to process.
         """
 
-        from openpype.hosts.webpublisher.cli_functions import (
+        from openpype.hosts.webpublisher.publish_functions import (
             cli_publish
         )
 

openpype/settings/defaults/project_settings/flame.json

@@ -17,7 +17,9 @@
             "workfileFrameStart": 1001,
             "handleStart": 5,
             "handleEnd": 5,
-            "includeHandles": false
+            "includeHandles": false,
+            "retimedHandles": true,
+            "retimedFramerange": true
         }
     },
     "publish": {

openpype/settings/defaults/project_settings/fusion.json

@@ -0,0 +1,12 @@
+{
+    "imageio": {
+        "ocio": {
+            "enabled": false,
+            "configFilePath": {
+                "windows": [],
+                "darwin": [],
+                "linux": []
+            }
+        }
+    }
+}

openpype/settings/defaults/project_settings/photoshop.json

@@ -15,6 +15,9 @@
         "CollectInstances": {
             "flatten_subset_template": ""
         },
+        "CollectReview": {
+            "publish": true
+        },
         "CollectVersion": {
             "enabled": false
         },

openpype/settings/defaults/system_settings/applications.json

@@ -706,30 +706,28 @@
         "icon": "{}/app_icons/fusion.png",
         "host_name": "fusion",
         "environment": {
-            "FUSION_UTILITY_SCRIPTS_SOURCE_DIR": [],
-            "FUSION_UTILITY_SCRIPTS_DIR": {
-                "windows": "{PROGRAMDATA}/Blackmagic Design/Fusion/Scripts/Comp",
-                "darwin": "/Library/Application Support/Blackmagic Design/Fusion/Scripts/Comp",
-                "linux": "/opt/Fusion/Scripts/Comp"
-            },
-            "PYTHON36": {
+            "FUSION_PYTHON3_HOME": {
                 "windows": "{LOCALAPPDATA}/Programs/Python/Python36",
                 "darwin": "~/Library/Python/3.6/bin",
                 "linux": "/opt/Python/3.6/bin"
-            },
-            "PYTHONPATH": [
-                "{PYTHON36}/Lib/site-packages",
-                "{VIRTUAL_ENV}/Lib/site-packages",
-                "{PYTHONPATH}"
-            ],
-            "PATH": [
-                "{PYTHON36}",
-                "{PYTHON36}/Scripts",
-                "{PATH}"
-            ],
-            "OPENPYPE_LOG_NO_COLORS": "Yes"
+            }
         },
         "variants": {
+            "18": {
+                "executables": {
+                    "windows": [
+                        "C:\\Program Files\\Blackmagic Design\\Fusion 18\\Fusion.exe"
+                    ],
+                    "darwin": [],
+                    "linux": []
+                },
+                "arguments": {
+                    "windows": [],
+                    "darwin": [],
+                    "linux": []
+                },
+                "environment": {}
+            },
             "17": {
                 "executables": {
                     "windows": [

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

@@ -90,6 +90,10 @@
                     "type": "schema",
                     "name": "schema_project_nuke"
                 },
+                {
+                    "type": "schema",
+                    "name": "schema_project_fusion"
+                },
                 {
                     "type": "schema",
                     "name": "schema_project_hiero"

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

@@ -128,6 +128,16 @@
                                 "type": "boolean",
                                 "key": "includeHandles",
                                 "label": "Enable handles including"
+                            },
+                            {
+                                "type": "boolean",
+                                "key": "retimedHandles",
+                                "label": "Enable retimed handles"
+                            },
+                            {
+                                "type": "boolean",
+                                "key": "retimedFramerange",
+                                "label": "Enable retimed shot frameranges"
                             }
                           ]
                         }

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

@@ -0,0 +1,38 @@
+{
+    "type": "dict",
+    "collapsible": true,
+    "key": "fusion",
+    "label": "Fusion",
+    "is_file": true,
+    "children": [
+        {
+            "key": "imageio",
+            "type": "dict",
+            "label": "Color Management (ImageIO)",
+            "collapsible": true,
+            "children": [
+                {
+                    "key": "ocio",
+                    "type": "dict",
+                    "label": "OpenColorIO (OCIO)",
+                    "collapsible": true,
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Set OCIO variable for Fusion"
+                        },
+                        {
+                            "type": "path",
+                            "key": "configFilePath",
+                            "label": "OCIO Config File Path",
+                            "multiplatform": true,
+                            "multipath": true
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

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

@@ -134,6 +134,18 @@
                 {
                     "type": "dict",
                     "collapsible": true,
+                    "key": "CollectReview",
+                    "label": "Collect Review",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "publish",
+                            "label": "Active"
+                         }
+                     ]
+                 },
+                 {
+                    "type": "dict",
                     "key": "CollectVersion",
                     "label": "Collect Version",
                     "children": [

openpype/widgets/nice_checkbox.py

@@ -111,14 +111,14 @@ class NiceCheckbox(QtWidgets.QFrame):
         return QtCore.QSize(width, height)
 
     def get_width_hint_by_height(self, height):
-        return (
-            height / self._base_size.height()
-        ) * self._base_size.width()
+        return int((
+            float(height) / self._base_size.height()
+        ) * self._base_size.width())
 
     def get_height_hint_by_width(self, width):
-        return (
-            width / self._base_size.width()
-        ) * self._base_size.height()
+        return int((
+            float(width) / self._base_size.width()
+        ) * self._base_size.height())
 
     def setFixedHeight(self, *args, **kwargs):
         self._fixed_height_set = True
@@ -321,7 +321,7 @@ class NiceCheckbox(QtWidgets.QFrame):
             bg_color = self.unchecked_bg_color
 
         else:
-            offset_ratio = self._current_step / self._steps
+            offset_ratio = float(self._current_step) / self._steps
             # Animation bg
             bg_color = self.steped_color(
                 self.checked_bg_color,
@@ -332,7 +332,8 @@ class NiceCheckbox(QtWidgets.QFrame):
         margins_ratio = self._checker_margins_divider
         if margins_ratio > 0:
             size_without_margins = int(
-                (frame_rect.height() / margins_ratio) * (margins_ratio - 2)
+                (float(frame_rect.height()) / margins_ratio)
+                * (margins_ratio - 2)
             )
             size_without_margins -= size_without_margins % 2
             margin_size_c = ceil(
@@ -434,21 +435,21 @@ class NiceCheckbox(QtWidgets.QFrame):
     def _get_enabled_icon_path(
         self, painter, checker_rect, step=None, half_steps=None
     ):
-        fifteenth = checker_rect.height() / 15
+        fifteenth = float(checker_rect.height()) / 15
         # Left point
         p1 = QtCore.QPoint(
-            checker_rect.x() + (5 * fifteenth),
-            checker_rect.y() + (9 * fifteenth)
+            int(checker_rect.x() + (5 * fifteenth)),
+            int(checker_rect.y() + (9 * fifteenth))
         )
         # Middle bottom point
         p2 = QtCore.QPoint(
             checker_rect.center().x(),
-            checker_rect.y() + (11 * fifteenth)
+            int(checker_rect.y() + (11 * fifteenth))
         )
         # Top right point
         p3 = QtCore.QPoint(
-            checker_rect.x() + (10 * fifteenth),
-            checker_rect.y() + (5 * fifteenth)
+            int(checker_rect.x() + (10 * fifteenth)),
+            int(checker_rect.y() + (5 * fifteenth))
         )
         if step is not None:
             multiplier = (half_steps - step)
@@ -458,16 +459,16 @@ class NiceCheckbox(QtWidgets.QFrame):
             p3c = p3 - checker_rect.center()
 
             p1o = QtCore.QPoint(
-                (p1c.x() / half_steps) * multiplier,
-                (p1c.y() / half_steps) * multiplier
+                int((float(p1c.x()) / half_steps) * multiplier),
+                int((float(p1c.y()) / half_steps) * multiplier)
             )
             p2o = QtCore.QPoint(
-                (p2c.x() / half_steps) * multiplier,
-                (p2c.y() / half_steps) * multiplier
+                int((float(p2c.x()) / half_steps) * multiplier),
+                int((float(p2c.y()) / half_steps) * multiplier)
             )
             p3o = QtCore.QPoint(
-                (p3c.x() / half_steps) * multiplier,
-                (p3c.y() / half_steps) * multiplier
+                int((float(p3c.x()) / half_steps) * multiplier),
+                int((float(p3c.y()) / half_steps) * multiplier)
             )
 
             p1 -= p1o
@@ -484,11 +485,12 @@ class NiceCheckbox(QtWidgets.QFrame):
         self, painter, checker_rect, step=None, half_steps=None
     ):
         center_point = QtCore.QPointF(
-            checker_rect.width() / 2, checker_rect.height() / 2
+            float(checker_rect.width()) / 2,
+            float(checker_rect.height()) / 2
         )
-        offset = (
+        offset = float((
             (center_point + QtCore.QPointF(0, 0)) / 2
-        ).x() / 4 * 5
+        ).x()) / 4 * 5
         if step is not None:
             diff = center_point.x() - offset
             diff_offset = (diff / half_steps) * (half_steps - step)

tests/lib/testing_classes.py

@@ -10,7 +10,7 @@ import glob
 import platform
 
 from tests.lib.db_handler import DBHandler
-from tests.lib.file_handler import RemoteFileHandler
+from distribution.file_handler import RemoteFileHandler
 
 
 class BaseTest: