OP-1937 - merge feature/OP-1920_Add-command-line-running-of-Site-Sync-server

CHANGELOG.md

@@ -1,6 +1,6 @@
 # Changelog
 
-## [3.5.1-nightly.1](https://github.com/pypeclub/OpenPype/tree/HEAD)
+## [3.6.0-nightly.1](https://github.com/pypeclub/OpenPype/tree/HEAD)
 
 [Full Changelog](https://github.com/pypeclub/OpenPype/compare/3.5.0...HEAD)
 
@@ -8,11 +8,13 @@
 
 - Tools: Experimental tools [\#2167](https://github.com/pypeclub/OpenPype/pull/2167)
 - Loader: Refactor and use OpenPype stylesheets [\#2166](https://github.com/pypeclub/OpenPype/pull/2166)
+- Add loader for linked smart objects in photoshop [\#2149](https://github.com/pypeclub/OpenPype/pull/2149)
 - Burnins: DNxHD profiles handling [\#2142](https://github.com/pypeclub/OpenPype/pull/2142)
 - Tools: Single access point for host tools [\#2139](https://github.com/pypeclub/OpenPype/pull/2139)
 
 **🐛 Bug fixes**
 
+- MacOS: Launching of applications may cause Permissions error [\#2175](https://github.com/pypeclub/OpenPype/pull/2175)
 - Blender: Fix 'Deselect All' with object not in 'Object Mode' [\#2163](https://github.com/pypeclub/OpenPype/pull/2163)
 - Tools: Stylesheets are applied after tool show [\#2161](https://github.com/pypeclub/OpenPype/pull/2161)
 - Maya: Collect render - fix UNC path support 🐛 [\#2158](https://github.com/pypeclub/OpenPype/pull/2158)
@@ -103,7 +105,7 @@
 - Settings for Nuke IncrementScriptVersion [\#2039](https://github.com/pypeclub/OpenPype/pull/2039)
 - Loader & Library loader: Use tools from OpenPype [\#2038](https://github.com/pypeclub/OpenPype/pull/2038)
 - Adding predefined project folders creation in PM [\#2030](https://github.com/pypeclub/OpenPype/pull/2030)
-- TimersManager: Removed interface of timers manager [\#2024](https://github.com/pypeclub/OpenPype/pull/2024)
+- WebserverModule: Removed interface of webserver module [\#2028](https://github.com/pypeclub/OpenPype/pull/2028)
 
 **🐛 Bug fixes**
 
@@ -125,8 +127,6 @@
 
 - Added possibility to configure of synchronization of workfile version… [\#2041](https://github.com/pypeclub/OpenPype/pull/2041)
 - General: Task types in profiles [\#2036](https://github.com/pypeclub/OpenPype/pull/2036)
-- WebserverModule: Removed interface of webserver module [\#2028](https://github.com/pypeclub/OpenPype/pull/2028)
-- Console interpreter: Handle invalid sizes on initialization [\#2022](https://github.com/pypeclub/OpenPype/pull/2022)
 
 **🐛 Bug fixes**
 

openpype/cli.py

@@ -317,3 +317,28 @@ def run(script):
 def runtests(folder, mark, pyargs):
     """Run all automatic tests after proper initialization via start.py"""
     PypeCommands().run_tests(folder, mark, pyargs)
+
+
+@main.command()
+@click.option("-d", "--debug",
+              is_flag=True, help=("Run process in debug mode"))
+@click.option("-a", "--active_site", required=True,
+              help="Name of active stie")
+def syncserver(debug, active_site):
+    """Run sync site server in background.
+
+        Some Site Sync use cases need to expose site to another one.
+        For example if majority of artists work in studio, they are not using
+        SS at all, but if you want to expose published assets to 'studio' site
+        to SFTP for only a couple of artists, some background process must
+        mark published assets to live on multiple sites (they might be
+        physically in same location - mounted shared disk).
+
+        Process mimics OP Tray with specific 'active_site' name, all
+        configuration for this "dummy" user comes from Setting or Local
+        Settings (configured by starting OP Tray with env
+        var SITE_SYNC_LOCAL_ID set to 'active_site'.
+    """
+    if debug:
+        os.environ['OPENPYPE_DEBUG'] = '3'
+    PypeCommands().syncserver(active_site)

openpype/hosts/flame/__init__.py

@@ -0,0 +1,105 @@
+from .api.utils import (
+    setup
+)
+
+from .api.pipeline import (
+    install,
+    uninstall,
+    ls,
+    containerise,
+    update_container,
+    maintained_selection,
+    remove_instance,
+    list_instances,
+    imprint
+)
+
+from .api.lib import (
+    FlameAppFramework,
+    maintain_current_timeline,
+    get_project_manager,
+    get_current_project,
+    get_current_timeline,
+    create_bin,
+)
+
+from .api.menu import (
+    FlameMenuProjectConnect,
+    FlameMenuTimeline
+)
+
+from .api.workio import (
+    open_file,
+    save_file,
+    current_file,
+    has_unsaved_changes,
+    file_extensions,
+    work_root
+)
+
+import os
+
+HOST_DIR = os.path.dirname(
+    os.path.abspath(__file__)
+)
+API_DIR = os.path.join(HOST_DIR, "api")
+PLUGINS_DIR = os.path.join(HOST_DIR, "plugins")
+PUBLISH_PATH = os.path.join(PLUGINS_DIR, "publish")
+LOAD_PATH = os.path.join(PLUGINS_DIR, "load")
+CREATE_PATH = os.path.join(PLUGINS_DIR, "create")
+INVENTORY_PATH = os.path.join(PLUGINS_DIR, "inventory")
+
+app_framework = None
+apps = []
+
+
+__all__ = [
+    "HOST_DIR",
+    "API_DIR",
+    "PLUGINS_DIR",
+    "PUBLISH_PATH",
+    "LOAD_PATH",
+    "CREATE_PATH",
+    "INVENTORY_PATH",
+    "INVENTORY_PATH",
+
+    "app_framework",
+    "apps",
+
+    # pipeline
+    "install",
+    "uninstall",
+    "ls",
+    "containerise",
+    "update_container",
+    "reload_pipeline",
+    "maintained_selection",
+    "remove_instance",
+    "list_instances",
+    "imprint",
+
+    # utils
+    "setup",
+
+    # lib
+    "FlameAppFramework",
+    "maintain_current_timeline",
+    "get_project_manager",
+    "get_current_project",
+    "get_current_timeline",
+    "create_bin",
+
+    # menu
+    "FlameMenuProjectConnect",
+    "FlameMenuTimeline",
+
+    # plugin
+
+    # workio
+    "open_file",
+    "save_file",
+    "current_file",
+    "has_unsaved_changes",
+    "file_extensions",
+    "work_root"
+]

openpype/hosts/flame/api/__init__.py

@@ -0,0 +1,3 @@
+"""
+OpenPype Autodesk Flame api
+"""

openpype/hosts/flame/api/lib.py

@@ -0,0 +1,276 @@
+import sys
+import os
+import pickle
+import contextlib
+from pprint import pformat
+
+from openpype.api import Logger
+
+log = Logger().get_logger(__name__)
+
+
+@contextlib.contextmanager
+def io_preferences_file(klass, filepath, write=False):
+    try:
+        flag = "w" if write else "r"
+        yield open(filepath, flag)
+
+    except IOError as _error:
+        klass.log.info("Unable to work with preferences `{}`: {}".format(
+            filepath, _error))
+
+
+class FlameAppFramework(object):
+    # flameAppFramework class takes care of preferences
+
+    class prefs_dict(dict):
+
+        def __init__(self, master, name, **kwargs):
+            self.name = name
+            self.master = master
+            if not self.master.get(self.name):
+                self.master[self.name] = {}
+            self.master[self.name].__init__()
+
+        def __getitem__(self, k):
+            return self.master[self.name].__getitem__(k)
+
+        def __setitem__(self, k, v):
+            return self.master[self.name].__setitem__(k, v)
+
+        def __delitem__(self, k):
+            return self.master[self.name].__delitem__(k)
+
+        def get(self, k, default=None):
+            return self.master[self.name].get(k, default)
+
+        def setdefault(self, k, default=None):
+            return self.master[self.name].setdefault(k, default)
+
+        def pop(self, k, v=object()):
+            if v is object():
+                return self.master[self.name].pop(k)
+            return self.master[self.name].pop(k, v)
+
+        def update(self, mapping=(), **kwargs):
+            self.master[self.name].update(mapping, **kwargs)
+
+        def __contains__(self, k):
+            return self.master[self.name].__contains__(k)
+
+        def copy(self):  # don"t delegate w/ super - dict.copy() -> dict :(
+            return type(self)(self)
+
+        def keys(self):
+            return self.master[self.name].keys()
+
+        @classmethod
+        def fromkeys(cls, keys, v=None):
+            return cls.master[cls.name].fromkeys(keys, v)
+
+        def __repr__(self):
+            return "{0}({1})".format(
+                type(self).__name__, self.master[self.name].__repr__())
+
+        def master_keys(self):
+            return self.master.keys()
+
+    def __init__(self):
+        self.name = self.__class__.__name__
+        self.bundle_name = "OpenPypeFlame"
+        # self.prefs scope is limited to flame project and user
+        self.prefs = {}
+        self.prefs_user = {}
+        self.prefs_global = {}
+        self.log = log
+
+        try:
+            import flame
+            self.flame = flame
+            self.flame_project_name = self.flame.project.current_project.name
+            self.flame_user_name = flame.users.current_user.name
+        except Exception:
+            self.flame = None
+            self.flame_project_name = None
+            self.flame_user_name = None
+
+        import socket
+        self.hostname = socket.gethostname()
+
+        if sys.platform == "darwin":
+            self.prefs_folder = os.path.join(
+                os.path.expanduser("~"),
+                "Library",
+                "Caches",
+                "OpenPype",
+                self.bundle_name
+            )
+        elif sys.platform.startswith("linux"):
+            self.prefs_folder = os.path.join(
+                os.path.expanduser("~"),
+                ".OpenPype",
+                self.bundle_name)
+
+        self.prefs_folder = os.path.join(
+            self.prefs_folder,
+            self.hostname,
+        )
+
+        self.log.info("[{}] waking up".format(self.__class__.__name__))
+        self.load_prefs()
+
+        # menu auto-refresh defaults
+
+        if not self.prefs_global.get("menu_auto_refresh"):
+            self.prefs_global["menu_auto_refresh"] = {
+                "media_panel": True,
+                "batch": True,
+                "main_menu": True,
+                "timeline_menu": True
+            }
+
+        self.apps = []
+
+    def get_pref_file_paths(self):
+
+        prefix = self.prefs_folder + os.path.sep + self.bundle_name
+        prefs_file_path = "_".join([
+            prefix, self.flame_user_name,
+            self.flame_project_name]) + ".prefs"
+        prefs_user_file_path = "_".join([
+            prefix, self.flame_user_name]) + ".prefs"
+        prefs_global_file_path = prefix + ".prefs"
+
+        return (prefs_file_path, prefs_user_file_path, prefs_global_file_path)
+
+    def load_prefs(self):
+
+        (proj_pref_path, user_pref_path,
+         glob_pref_path) = self.get_pref_file_paths()
+
+        with io_preferences_file(self, proj_pref_path) as prefs_file:
+            self.prefs = pickle.load(prefs_file)
+            self.log.info(
+                "Project - preferences contents:\n{}".format(
+                    pformat(self.prefs)
+                ))
+
+        with io_preferences_file(self, user_pref_path) as prefs_file:
+            self.prefs_user = pickle.load(prefs_file)
+            self.log.info(
+                "User - preferences contents:\n{}".format(
+                    pformat(self.prefs_user)
+                ))
+
+        with io_preferences_file(self, glob_pref_path) as prefs_file:
+            self.prefs_global = pickle.load(prefs_file)
+            self.log.info(
+                "Global - preferences contents:\n{}".format(
+                    pformat(self.prefs_global)
+                ))
+
+        return True
+
+    def save_prefs(self):
+        # make sure the preference folder is available
+        if not os.path.isdir(self.prefs_folder):
+            try:
+                os.makedirs(self.prefs_folder)
+            except Exception:
+                self.log.info("Unable to create folder {}".format(
+                    self.prefs_folder))
+                return False
+
+        # get all pref file paths
+        (proj_pref_path, user_pref_path,
+         glob_pref_path) = self.get_pref_file_paths()
+
+        with io_preferences_file(self, proj_pref_path, True) as prefs_file:
+            pickle.dump(self.prefs, prefs_file)
+            self.log.info(
+                "Project - preferences contents:\n{}".format(
+                    pformat(self.prefs)
+                ))
+
+        with io_preferences_file(self, user_pref_path, True) as prefs_file:
+            pickle.dump(self.prefs_user, prefs_file)
+            self.log.info(
+                "User - preferences contents:\n{}".format(
+                    pformat(self.prefs_user)
+                ))
+
+        with io_preferences_file(self, glob_pref_path, True) as prefs_file:
+            pickle.dump(self.prefs_global, prefs_file)
+            self.log.info(
+                "Global - preferences contents:\n{}".format(
+                    pformat(self.prefs_global)
+                ))
+
+        return True
+
+
+@contextlib.contextmanager
+def maintain_current_timeline(to_timeline, from_timeline=None):
+    """Maintain current timeline selection during context
+
+    Attributes:
+        from_timeline (resolve.Timeline)[optional]:
+    Example:
+        >>> print(from_timeline.GetName())
+        timeline1
+        >>> print(to_timeline.GetName())
+        timeline2
+
+        >>> with maintain_current_timeline(to_timeline):
+        ...     print(get_current_timeline().GetName())
+        timeline2
+
+        >>> print(get_current_timeline().GetName())
+        timeline1
+    """
+    # todo: this is still Resolve's implementation
+    project = get_current_project()
+    working_timeline = from_timeline or project.GetCurrentTimeline()
+
+    # swith to the input timeline
+    project.SetCurrentTimeline(to_timeline)
+
+    try:
+        # do a work
+        yield
+    finally:
+        # put the original working timeline to context
+        project.SetCurrentTimeline(working_timeline)
+
+
+def get_project_manager():
+    # TODO: get_project_manager
+    return
+
+
+def get_media_storage():
+    # TODO: get_media_storage
+    return
+
+
+def get_current_project():
+    # TODO: get_current_project
+    return
+
+
+def get_current_timeline(new=False):
+    # TODO: get_current_timeline
+    return
+
+
+def create_bin(name, root=None):
+    # TODO: create_bin
+    return
+
+
+def rescan_hooks():
+    import flame
+    try:
+        flame.execute_shortcut('Rescan Python Hooks')
+    except Exception:
+        pass

openpype/hosts/flame/api/menu.py

@@ -0,0 +1,208 @@
+import os
+from Qt import QtWidgets
+from copy import deepcopy
+
+from openpype.tools.utils.host_tools import HostToolsHelper
+
+
+menu_group_name = 'OpenPype'
+
+default_flame_export_presets = {
+    'Publish': {
+        'PresetVisibility': 2,
+        'PresetType': 0,
+        'PresetFile': 'OpenEXR/OpenEXR (16-bit fp PIZ).xml'
+    },
+    'Preview': {
+        'PresetVisibility': 3,
+        'PresetType': 2,
+        'PresetFile': 'Generate Preview.xml'
+    },
+    'Thumbnail': {
+        'PresetVisibility': 3,
+        'PresetType': 0,
+        'PresetFile': 'Generate Thumbnail.xml'
+    }
+}
+
+
+class _FlameMenuApp(object):
+    def __init__(self, framework):
+        self.name = self.__class__.__name__
+        self.framework = framework
+        self.log = framework.log
+        self.menu_group_name = menu_group_name
+        self.dynamic_menu_data = {}
+
+        # flame module is only avaliable when a
+        # flame project is loaded and initialized
+        self.flame = None
+        try:
+            import flame
+            self.flame = flame
+        except ImportError:
+            self.flame = None
+
+        self.flame_project_name = flame.project.current_project.name
+        self.prefs = self.framework.prefs_dict(self.framework.prefs, self.name)
+        self.prefs_user = self.framework.prefs_dict(
+            self.framework.prefs_user, self.name)
+        self.prefs_global = self.framework.prefs_dict(
+            self.framework.prefs_global, self.name)
+
+        self.mbox = QtWidgets.QMessageBox()
+
+        self.menu = {
+            "actions": [{
+                'name': os.getenv("AVALON_PROJECT", "project"),
+                'isEnabled': False
+            }],
+            "name": self.menu_group_name
+        }
+        self.tools_helper = HostToolsHelper()
+
+    def __getattr__(self, name):
+        def method(*args, **kwargs):
+            print('calling %s' % name)
+        return method
+
+    def rescan(self, *args, **kwargs):
+        if not self.flame:
+            try:
+                import flame
+                self.flame = flame
+            except ImportError:
+                self.flame = None
+
+        if self.flame:
+            self.flame.execute_shortcut('Rescan Python Hooks')
+            self.log.info('Rescan Python Hooks')
+
+
+class FlameMenuProjectConnect(_FlameMenuApp):
+
+    # flameMenuProjectconnect app takes care of the preferences dialog as well
+
+    def __init__(self, framework):
+        _FlameMenuApp.__init__(self, framework)
+
+    def __getattr__(self, name):
+        def method(*args, **kwargs):
+            project = self.dynamic_menu_data.get(name)
+            if project:
+                self.link_project(project)
+        return method
+
+    def build_menu(self):
+        if not self.flame:
+            return []
+
+        flame_project_name = self.flame_project_name
+        self.log.info("______ {} ______".format(flame_project_name))
+
+        menu = deepcopy(self.menu)
+
+        menu['actions'].append({
+            "name": "Workfiles ...",
+            "execute": lambda x: self.tools_helper.show_workfiles()
+        })
+        menu['actions'].append({
+            "name": "Create ...",
+            "execute": lambda x: self.tools_helper.show_creator()
+        })
+        menu['actions'].append({
+            "name": "Publish ...",
+            "execute": lambda x: self.tools_helper.show_publish()
+        })
+        menu['actions'].append({
+            "name": "Load ...",
+            "execute": lambda x: self.tools_helper.show_loader()
+        })
+        menu['actions'].append({
+            "name": "Manage ...",
+            "execute": lambda x: self.tools_helper.show_scene_inventory()
+        })
+        menu['actions'].append({
+            "name": "Library ...",
+            "execute": lambda x: self.tools_helper.show_library_loader()
+        })
+        return menu
+
+    def get_projects(self, *args, **kwargs):
+        pass
+
+    def refresh(self, *args, **kwargs):
+        self.rescan()
+
+    def rescan(self, *args, **kwargs):
+        if not self.flame:
+            try:
+                import flame
+                self.flame = flame
+            except ImportError:
+                self.flame = None
+
+        if self.flame:
+            self.flame.execute_shortcut('Rescan Python Hooks')
+            self.log.info('Rescan Python Hooks')
+
+
+class FlameMenuTimeline(_FlameMenuApp):
+
+    # flameMenuProjectconnect app takes care of the preferences dialog as well
+
+    def __init__(self, framework):
+        _FlameMenuApp.__init__(self, framework)
+
+    def __getattr__(self, name):
+        def method(*args, **kwargs):
+            project = self.dynamic_menu_data.get(name)
+            if project:
+                self.link_project(project)
+        return method
+
+    def build_menu(self):
+        if not self.flame:
+            return []
+
+        flame_project_name = self.flame_project_name
+        self.log.info("______ {} ______".format(flame_project_name))
+
+        menu = deepcopy(self.menu)
+
+        menu['actions'].append({
+            "name": "Create ...",
+            "execute": lambda x: self.tools_helper.show_creator()
+        })
+        menu['actions'].append({
+            "name": "Publish ...",
+            "execute": lambda x: self.tools_helper.show_publish()
+        })
+        menu['actions'].append({
+            "name": "Load ...",
+            "execute": lambda x: self.tools_helper.show_loader()
+        })
+        menu['actions'].append({
+            "name": "Manage ...",
+            "execute": lambda x: self.tools_helper.show_scene_inventory()
+        })
+
+        return menu
+
+    def get_projects(self, *args, **kwargs):
+        pass
+
+    def refresh(self, *args, **kwargs):
+        self.rescan()
+
+    def rescan(self, *args, **kwargs):
+        if not self.flame:
+            try:
+                import flame
+                self.flame = flame
+            except ImportError:
+                self.flame = None
+
+        if self.flame:
+            self.flame.execute_shortcut('Rescan Python Hooks')
+            self.log.info('Rescan Python Hooks')

openpype/hosts/flame/api/pipeline.py

@@ -0,0 +1,155 @@
+"""
+Basic avalon integration
+"""
+import contextlib
+from avalon import api as avalon
+from pyblish import api as pyblish
+from openpype.api import Logger
+
+AVALON_CONTAINERS = "AVALON_CONTAINERS"
+
+log = Logger().get_logger(__name__)
+
+
+def install():
+    from .. import (
+        PUBLISH_PATH,
+        LOAD_PATH,
+        CREATE_PATH,
+        INVENTORY_PATH
+    )
+    # TODO: install
+
+    # Disable all families except for the ones we explicitly want to see
+    family_states = [
+        "imagesequence",
+        "render2d",
+        "plate",
+        "render",
+        "mov",
+        "clip"
+    ]
+    avalon.data["familiesStateDefault"] = False
+    avalon.data["familiesStateToggled"] = family_states
+
+    log.info("openpype.hosts.flame installed")
+
+    pyblish.register_host("flame")
+    pyblish.register_plugin_path(PUBLISH_PATH)
+    log.info("Registering Flame plug-ins..")
+
+    avalon.register_plugin_path(avalon.Loader, LOAD_PATH)
+    avalon.register_plugin_path(avalon.Creator, CREATE_PATH)
+    avalon.register_plugin_path(avalon.InventoryAction, INVENTORY_PATH)
+
+    # register callback for switching publishable
+    pyblish.register_callback("instanceToggled", on_pyblish_instance_toggled)
+
+
+def uninstall():
+    from .. import (
+        PUBLISH_PATH,
+        LOAD_PATH,
+        CREATE_PATH,
+        INVENTORY_PATH
+    )
+
+    # TODO: uninstall
+    pyblish.deregister_host("flame")
+    pyblish.deregister_plugin_path(PUBLISH_PATH)
+    log.info("Deregistering DaVinci Resovle plug-ins..")
+
+    avalon.deregister_plugin_path(avalon.Loader, LOAD_PATH)
+    avalon.deregister_plugin_path(avalon.Creator, CREATE_PATH)
+    avalon.deregister_plugin_path(avalon.InventoryAction, INVENTORY_PATH)
+
+    # register callback for switching publishable
+    pyblish.deregister_callback("instanceToggled", on_pyblish_instance_toggled)
+
+
+def containerise(tl_segment,
+                 name,
+                 namespace,
+                 context,
+                 loader=None,
+                 data=None):
+    # TODO: containerise
+    pass
+
+
+def ls():
+    """List available containers.
+    """
+    # TODO: ls
+    pass
+
+
+def parse_container(tl_segment, validate=True):
+    """Return container data from timeline_item's openpype tag.
+    """
+    # TODO: parse_container
+    pass
+
+
+def update_container(tl_segment, data=None):
+    """Update container data to input timeline_item's openpype tag.
+    """
+    # TODO: update_container
+    pass
+
+
+@contextlib.contextmanager
+def maintained_selection():
+    """Maintain selection during context
+
+    Example:
+        >>> with maintained_selection():
+        ...     node['selected'].setValue(True)
+        >>> print(node['selected'].value())
+        False
+    """
+    # TODO: maintained_selection + remove undo steps
+
+    try:
+        # do the operation
+        yield
+    finally:
+        pass
+
+
+def reset_selection():
+    """Deselect all selected nodes
+    """
+    pass
+
+
+def on_pyblish_instance_toggled(instance, old_value, new_value):
+    """Toggle node passthrough states on instance toggles."""
+
+    log.info("instance toggle: {}, old_value: {}, new_value:{} ".format(
+        instance, old_value, new_value))
+
+    # from openpype.hosts.resolve import (
+    #     set_publish_attribute
+    # )
+
+    # # Whether instances should be passthrough based on new value
+    # timeline_item = instance.data["item"]
+    # set_publish_attribute(timeline_item, new_value)
+
+
+def remove_instance(instance):
+    """Remove instance marker from track item."""
+    # TODO: remove_instance
+    pass
+
+
+def list_instances():
+    """List all created instances from current workfile."""
+    # TODO: list_instances
+    pass
+
+
+def imprint(item, data=None):
+    # TODO: imprint
+    pass

openpype/hosts/flame/api/plugin.py

@@ -0,0 +1,3 @@
+# Creator plugin functions
+# Publishing plugin functions
+# Loader plugin functions

openpype/hosts/flame/api/utils.py

@@ -0,0 +1,108 @@
+"""
+Flame utils for syncing scripts
+"""
+
+import os
+import shutil
+from openpype.api import Logger
+log = Logger().get_logger(__name__)
+
+
+def _sync_utility_scripts(env=None):
+    """ Synchronizing basic utlility scripts for flame.
+
+    To be able to run start OpenPype within Flame we have to copy
+    all utility_scripts and additional FLAME_SCRIPT_DIR into
+    `/opt/Autodesk/shared/python`. This will be always synchronizing those
+    folders.
+    """
+    from .. import HOST_DIR
+
+    env = env or os.environ
+
+    # initiate inputs
+    scripts = {}
+    fsd_env = env.get("FLAME_SCRIPT_DIRS", "")
+    flame_shared_dir = "/opt/Autodesk/shared/python"
+
+    fsd_paths = [os.path.join(
+        HOST_DIR,
+        "utility_scripts"
+    )]
+
+    # collect script dirs
+    log.info("FLAME_SCRIPT_DIRS: `{fsd_env}`".format(**locals()))
+    log.info("fsd_paths: `{fsd_paths}`".format(**locals()))
+
+    # add application environment setting for FLAME_SCRIPT_DIR
+    # to script path search
+    for _dirpath in fsd_env.split(os.pathsep):
+        if not os.path.isdir(_dirpath):
+            log.warning("Path is not a valid dir: `{_dirpath}`".format(
+                **locals()))
+            continue
+        fsd_paths.append(_dirpath)
+
+    # collect scripts from dirs
+    for path in fsd_paths:
+        scripts.update({path: os.listdir(path)})
+
+    remove_black_list = []
+    for _k, s_list in scripts.items():
+        remove_black_list += s_list
+
+    log.info("remove_black_list: `{remove_black_list}`".format(**locals()))
+    log.info("Additional Flame script paths: `{fsd_paths}`".format(**locals()))
+    log.info("Flame Scripts: `{scripts}`".format(**locals()))
+
+    # make sure no script file is in folder
+    if next(iter(os.listdir(flame_shared_dir)), None):
+        for _itm in os.listdir(flame_shared_dir):
+            skip = False
+
+            # skip all scripts and folders which are not maintained
+            if _itm not in remove_black_list:
+                skip = True
+
+            # do not skyp if pyc in extension
+            if not os.path.isdir(_itm) and "pyc" in os.path.splitext(_itm)[-1]:
+                skip = False
+
+            # continue if skip in true
+            if skip:
+                continue
+
+            path = os.path.join(flame_shared_dir, _itm)
+            log.info("Removing `{path}`...".format(**locals()))
+            if os.path.isdir(path):
+                shutil.rmtree(path, onerror=None)
+            else:
+                os.remove(path)
+
+    # copy scripts into Resolve's utility scripts dir
+    for dirpath, scriptlist in scripts.items():
+        # directory and scripts list
+        for _script in scriptlist:
+            # script in script list
+            src = os.path.join(dirpath, _script)
+            dst = os.path.join(flame_shared_dir, _script)
+            log.info("Copying `{src}` to `{dst}`...".format(**locals()))
+            if os.path.isdir(src):
+                shutil.copytree(
+                    src, dst, symlinks=False,
+                    ignore=None, ignore_dangling_symlinks=False
+                )
+            else:
+                shutil.copy2(src, dst)
+
+
+def setup(env=None):
+    """ Wrapper installer started from
+    `flame/hooks/pre_flame_setup.py`
+    """
+    env = env or os.environ
+
+    # synchronize resolve utility scripts
+    _sync_utility_scripts(env)
+
+    log.info("Flame OpenPype wrapper has been installed")

openpype/hosts/flame/api/workio.py

@@ -0,0 +1,37 @@
+"""Host API required Work Files tool"""
+
+import os
+from openpype.api import Logger
+# from .. import (
+#     get_project_manager,
+#     get_current_project
+# )
+
+
+log = Logger().get_logger(__name__)
+
+exported_projet_ext = ".otoc"
+
+
+def file_extensions():
+    return [exported_projet_ext]
+
+
+def has_unsaved_changes():
+    pass
+
+
+def save_file(filepath):
+    pass
+
+
+def open_file(filepath):
+    pass
+
+
+def current_file():
+    pass
+
+
+def work_root(session):
+    return os.path.normpath(session["AVALON_WORKDIR"]).replace("\\", "/")

openpype/hosts/flame/hooks/pre_flame_setup.py

@@ -0,0 +1,132 @@
+import os
+import json
+import tempfile
+import contextlib
+from openpype.lib import (
+    PreLaunchHook, get_openpype_username)
+from openpype.hosts import flame as opflame
+import openpype
+from pprint import pformat
+
+
+class FlamePrelaunch(PreLaunchHook):
+    """ Flame prelaunch hook
+
+    Will make sure flame_script_dirs are coppied to user's folder defined
+    in environment var FLAME_SCRIPT_DIR.
+    """
+    app_groups = ["flame"]
+
+    # todo: replace version number with avalon launch app version
+    flame_python_exe = "/opt/Autodesk/python/2021/bin/python2.7"
+
+    wtc_script_path = os.path.join(
+        opflame.HOST_DIR, "scripts", "wiretap_com.py")
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.signature = "( {} )".format(self.__class__.__name__)
+
+    def execute(self):
+        """Hook entry method."""
+        project_doc = self.data["project_doc"]
+        user_name = get_openpype_username()
+
+        self.log.debug("Collected user \"{}\"".format(user_name))
+        self.log.info(pformat(project_doc))
+        _db_p_data = project_doc["data"]
+        width = _db_p_data["resolutionWidth"]
+        height = _db_p_data["resolutionHeight"]
+        fps = int(_db_p_data["fps"])
+
+        project_data = {
+            "Name": project_doc["name"],
+            "Nickname": _db_p_data["code"],
+            "Description": "Created by OpenPype",
+            "SetupDir": project_doc["name"],
+            "FrameWidth": int(width),
+            "FrameHeight": int(height),
+            "AspectRatio": float((width / height) * _db_p_data["pixelAspect"]),
+            "FrameRate": "{} fps".format(fps),
+            "FrameDepth": "16-bit fp",
+            "FieldDominance": "PROGRESSIVE"
+        }
+
+        data_to_script = {
+            # from settings
+            "host_name": "localhost",
+            "volume_name": "stonefs",
+            "group_name": "staff",
+            "color_policy": "ACES 1.1",
+
+            # from project
+            "project_name": project_doc["name"],
+            "user_name": user_name,
+            "project_data": project_data
+        }
+        app_arguments = self._get_launch_arguments(data_to_script)
+
+        self.log.info(pformat(dict(self.launch_context.env)))
+
+        opflame.setup(self.launch_context.env)
+
+        self.launch_context.launch_args.extend(app_arguments)
+
+    def _get_launch_arguments(self, script_data):
+        # Dump data to string
+        dumped_script_data = json.dumps(script_data)
+
+        with make_temp_file(dumped_script_data) as tmp_json_path:
+            # Prepare subprocess arguments
+            args = [
+                self.flame_python_exe,
+                self.wtc_script_path,
+                tmp_json_path
+            ]
+            self.log.info("Executing: {}".format(" ".join(args)))
+
+            process_kwargs = {
+                "logger": self.log,
+                "env": {}
+            }
+
+            openpype.api.run_subprocess(args, **process_kwargs)
+
+            # process returned json file to pass launch args
+            return_json_data = open(tmp_json_path).read()
+            returned_data = json.loads(return_json_data)
+            app_args = returned_data.get("app_args")
+            self.log.info("____ app_args: `{}`".format(app_args))
+
+            if not app_args:
+                RuntimeError("App arguments were not solved")
+
+        return app_args
+
+
+@contextlib.contextmanager
+def make_temp_file(data):
+    try:
+        # Store dumped json to temporary file
+        temporary_json_file = tempfile.NamedTemporaryFile(
+            mode="w", suffix=".json", delete=False
+        )
+        temporary_json_file.write(data)
+        temporary_json_file.close()
+        temporary_json_filepath = temporary_json_file.name.replace(
+            "\\", "/"
+        )
+
+        yield temporary_json_filepath
+
+    except IOError as _error:
+        raise IOError(
+            "Not able to create temp json file: {}".format(
+                _error
+            )
+        )
+
+    finally:
+        # Remove the temporary json
+        os.remove(temporary_json_filepath)

openpype/hosts/flame/scripts/wiretap_com.py

@@ -0,0 +1,490 @@
+#!/usr/bin/env python2.7
+# -*- coding: utf-8 -*-
+
+from __future__ import absolute_import
+import os
+import sys
+import subprocess
+import json
+import xml.dom.minidom as minidom
+from copy import deepcopy
+import datetime
+
+try:
+    from libwiretapPythonClientAPI import (
+        WireTapClientInit)
+except ImportError:
+    flame_python_path = "/opt/Autodesk/flame_2021/python"
+    flame_exe_path = (
+        "/opt/Autodesk/flame_2021/bin/flame.app"
+        "/Contents/MacOS/startApp")
+
+    sys.path.append(flame_python_path)
+
+    from libwiretapPythonClientAPI import (
+        WireTapClientInit,
+        WireTapClientUninit,
+        WireTapNodeHandle,
+        WireTapServerHandle,
+        WireTapInt,
+        WireTapStr
+    )
+
+
+class WireTapCom(object):
+    """
+    Comunicator class wrapper for talking to WireTap db.
+
+    This way we are able to set new project with settings and
+    correct colorspace policy. Also we are able to create new user
+    or get actuall user with similar name (users are usually cloning
+    their profiles and adding date stamp into suffix).
+    """
+
+    def __init__(self, host_name=None, volume_name=None, group_name=None):
+        """Initialisation of WireTap communication class
+
+        Args:
+            host_name (str, optional): Name of host server. Defaults to None.
+            volume_name (str, optional): Name of volume. Defaults to None.
+            group_name (str, optional): Name of user group. Defaults to None.
+        """
+        # set main attributes of server
+        # if there are none set the default installation
+        self.host_name = host_name or "localhost"
+        self.volume_name = volume_name or "stonefs"
+        self.group_name = group_name or "staff"
+
+        # initialize WireTap client
+        WireTapClientInit()
+
+        # add the server to shared variable
+        self._server = WireTapServerHandle("{}:IFFFS".format(self.host_name))
+        print("WireTap connected at '{}'...".format(
+            self.host_name))
+
+    def close(self):
+        self._server = None
+        WireTapClientUninit()
+        print("WireTap closed...")
+
+    def get_launch_args(
+            self, project_name, project_data, user_name, *args, **kwargs):
+        """Forming launch arguments for OpenPype launcher.
+
+        Args:
+            project_name (str): name of project
+            project_data (dict): Flame compatible project data
+            user_name (str): name of user
+
+        Returns:
+            list: arguments
+        """
+
+        workspace_name = kwargs.get("workspace_name")
+        color_policy = kwargs.get("color_policy")
+
+        self._project_prep(project_name)
+        self._set_project_settings(project_name, project_data)
+        self._set_project_colorspace(project_name, color_policy)
+        user_name = self._user_prep(user_name)
+
+        if workspace_name is None:
+            # default workspace
+            print("Using a default workspace")
+            return [
+                "--start-project={}".format(project_name),
+                "--start-user={}".format(user_name),
+                "--create-workspace"
+            ]
+
+        else:
+            print(
+                "Using a custom workspace '{}'".format(workspace_name))
+
+            self._workspace_prep(project_name, workspace_name)
+            return [
+                "--start-project={}".format(project_name),
+                "--start-user={}".format(user_name),
+                "--create-workspace",
+                "--start-workspace={}".format(workspace_name)
+            ]
+
+    def _workspace_prep(self, project_name, workspace_name):
+        """Preparing a workspace
+
+        In case it doesn not exists it will create one
+
+        Args:
+            project_name (str): project name
+            workspace_name (str): workspace name
+
+        Raises:
+            AttributeError: unable to create workspace
+        """
+        workspace_exists = self._child_is_in_parent_path(
+            "/projects/{}".format(project_name), workspace_name, "WORKSPACE"
+        )
+        if not workspace_exists:
+            project = WireTapNodeHandle(
+                self._server, "/projects/{}".format(project_name))
+
+            workspace_node = WireTapNodeHandle()
+            created_workspace = project.createNode(
+                workspace_name, "WORKSPACE", workspace_node)
+
+            if not created_workspace:
+                raise AttributeError(
+                    "Cannot create workspace `{}` in "
+                    "project `{}`: `{}`".format(
+                        workspace_name, project_name, project.lastError())
+                )
+
+        print(
+            "Workspace `{}` is successfully created".format(workspace_name))
+
+    def _project_prep(self, project_name):
+        """Preparing a project
+
+        In case it doesn not exists it will create one
+
+        Args:
+            project_name (str): project name
+
+        Raises:
+            AttributeError: unable to create project
+        """
+        # test if projeft exists
+        project_exists = self._child_is_in_parent_path(
+            "/projects", project_name, "PROJECT")
+
+        if not project_exists:
+            volumes = self._get_all_volumes()
+
+            if len(volumes) == 0:
+                raise AttributeError(
+                    "Not able to create new project. No Volumes existing"
+                )
+
+            # check if volumes exists
+            if self.volume_name not in volumes:
+                raise AttributeError(
+                    ("Volume '{}' does not exist '{}'").format(
+                        self.volume_name, volumes)
+                )
+
+            # form cmd arguments
+            project_create_cmd = [
+                os.path.join(
+                    "/opt/Autodesk/",
+                    "wiretap",
+                    "tools",
+                    "2021",
+                    "wiretap_create_node",
+                ),
+                '-n',
+                os.path.join("/volumes", self.volume_name),
+                '-d',
+                project_name,
+                '-g',
+            ]
+
+            project_create_cmd.append(self.group_name)
+
+            print(project_create_cmd)
+
+            exit_code = subprocess.call(
+                project_create_cmd,
+                cwd=os.path.expanduser('~'))
+
+            if exit_code != 0:
+                RuntimeError("Cannot create project in flame db")
+
+            print(
+                "A new project '{}' is created.".format(project_name))
+
+    def _get_all_volumes(self):
+        """Request all available volumens from WireTap
+
+        Returns:
+            list: all available volumes in server
+
+        Rises:
+            AttributeError: unable to get any volumes childs from server
+        """
+        root = WireTapNodeHandle(self._server, "/volumes")
+        children_num = WireTapInt(0)
+
+        get_children_num = root.getNumChildren(children_num)
+        if not get_children_num:
+            raise AttributeError(
+                "Cannot get number of volumes: {}".format(root.lastError())
+            )
+
+        volumes = []
+
+        # go trough all children and get volume names
+        child_obj = WireTapNodeHandle()
+        for child_idx in range(children_num):
+
+            # get a child
+            if not root.getChild(child_idx, child_obj):
+                raise AttributeError(
+                    "Unable to get child: {}".format(root.lastError()))
+
+            node_name = WireTapStr()
+            get_children_name = child_obj.getDisplayName(node_name)
+
+            if not get_children_name:
+                raise AttributeError(
+                    "Unable to get child name: {}".format(
+                        child_obj.lastError())
+                )
+
+            volumes.append(node_name.c_str())
+
+        return volumes
+
+    def _user_prep(self, user_name):
+        """Ensuring user does exists in user's stack
+
+        Args:
+            user_name (str): name of a user
+
+        Raises:
+            AttributeError: unable to create user
+        """
+
+        # get all used usernames in db
+        used_names = self._get_usernames()
+        print(">> used_names: {}".format(used_names))
+
+        # filter only those which are sharing input user name
+        filtered_users = [user for user in used_names if user_name in user]
+
+        if filtered_users:
+            # todo: need to find lastly created following regex patern for
+            # date used in name
+            return filtered_users.pop()
+
+        # create new user name with date in suffix
+        now = datetime.datetime.now()  # current date and time
+        date = now.strftime("%Y%m%d")
+        new_user_name = "{}_{}".format(user_name, date)
+        print(new_user_name)
+
+        if not self._child_is_in_parent_path("/users", new_user_name, "USER"):
+            # Create the new user
+            users = WireTapNodeHandle(self._server, "/users")
+
+            user_node = WireTapNodeHandle()
+            created_user = users.createNode(new_user_name, "USER", user_node)
+            if not created_user:
+                raise AttributeError(
+                    "User {} cannot be created: {}".format(
+                        new_user_name, users.lastError())
+                )
+
+            print("User `{}` is created".format(new_user_name))
+            return new_user_name
+
+    def _get_usernames(self):
+        """Requesting all available users from WireTap
+
+        Returns:
+            list: all available user names
+
+        Raises:
+            AttributeError: there are no users in server
+        """
+        root = WireTapNodeHandle(self._server, "/users")
+        children_num = WireTapInt(0)
+
+        get_children_num = root.getNumChildren(children_num)
+        if not get_children_num:
+            raise AttributeError(
+                "Cannot get number of volumes: {}".format(root.lastError())
+            )
+
+        usernames = []
+
+        # go trough all children and get volume names
+        child_obj = WireTapNodeHandle()
+        for child_idx in range(children_num):
+
+            # get a child
+            if not root.getChild(child_idx, child_obj):
+                raise AttributeError(
+                    "Unable to get child: {}".format(root.lastError()))
+
+            node_name = WireTapStr()
+            get_children_name = child_obj.getDisplayName(node_name)
+
+            if not get_children_name:
+                raise AttributeError(
+                    "Unable to get child name: {}".format(
+                        child_obj.lastError())
+                )
+
+            usernames.append(node_name.c_str())
+
+        return usernames
+
+    def _child_is_in_parent_path(self, parent_path, child_name, child_type):
+        """Checking if a given child is in parent path.
+
+        Args:
+            parent_path (str): db path to parent
+            child_name (str): name of child
+            child_type (str): type of child
+
+        Raises:
+            AttributeError: Not able to get number of children
+            AttributeError: Not able to get children form parent
+            AttributeError: Not able to get children name
+            AttributeError: Not able to get children type
+
+        Returns:
+            bool: True if child is in parent path
+        """
+        parent = WireTapNodeHandle(self._server, parent_path)
+
+        # iterate number of children
+        children_num = WireTapInt(0)
+        requested = parent.getNumChildren(children_num)
+        if not requested:
+            raise AttributeError((
+                "Error: Cannot request number of "
+                "childrens from the node {}. Make sure your "
+                "wiretap service is running: {}").format(
+                    parent_path, parent.lastError())
+            )
+
+        # iterate children
+        child_obj = WireTapNodeHandle()
+        for child_idx in range(children_num):
+            if not parent.getChild(child_idx, child_obj):
+                raise AttributeError(
+                    "Cannot get child: {}".format(
+                        parent.lastError()))
+
+            node_name = WireTapStr()
+            node_type = WireTapStr()
+
+            if not child_obj.getDisplayName(node_name):
+                raise AttributeError(
+                    "Unable to get child name: %s" % child_obj.lastError()
+                )
+            if not child_obj.getNodeTypeStr(node_type):
+                raise AttributeError(
+                    "Unable to obtain child type: %s" % child_obj.lastError()
+                )
+
+            if (node_name.c_str() == child_name) and (
+                    node_type.c_str() == child_type):
+                return True
+
+        return False
+
+    def _set_project_settings(self, project_name, project_data):
+        """Setting project attributes.
+
+        Args:
+            project_name (str): name of project
+            project_data (dict): data with project attributes
+                                 (flame compatible)
+
+        Raises:
+            AttributeError: Not able to set project attributes
+        """
+        # generated xml from project_data dict
+        _xml = "<Project>"
+        for key, value in project_data.items():
+            _xml += "<{}>{}</{}>".format(key, value, key)
+        _xml += "</Project>"
+
+        pretty_xml = minidom.parseString(_xml).toprettyxml()
+        print("__ xml: {}".format(pretty_xml))
+
+        # set project data to wiretap
+        project_node = WireTapNodeHandle(
+            self._server, "/projects/{}".format(project_name))
+
+        if not project_node.setMetaData("XML", _xml):
+            raise AttributeError(
+                "Not able to set project attributes {}. Error: {}".format(
+                    project_name, project_node.lastError())
+            )
+
+        print("Project settings successfully set.")
+
+    def _set_project_colorspace(self, project_name, color_policy):
+        """Set project's colorspace policy.
+
+        Args:
+            project_name (str): name of project
+            color_policy (str): name of policy
+
+        Raises:
+            RuntimeError: Not able to set colorspace policy
+        """
+        color_policy = color_policy or "Legacy"
+        project_colorspace_cmd = [
+            os.path.join(
+                "/opt/Autodesk/",
+                "wiretap",
+                "tools",
+                "2021",
+                "wiretap_duplicate_node",
+            ),
+            "-s",
+            "/syncolor/policies/Autodesk/{}".format(color_policy),
+            "-n",
+            "/projects/{}/syncolor".format(project_name)
+        ]
+
+        print(project_colorspace_cmd)
+
+        exit_code = subprocess.call(
+            project_colorspace_cmd,
+            cwd=os.path.expanduser('~'))
+
+        if exit_code != 0:
+            RuntimeError("Cannot set colorspace {} on project {}".format(
+                color_policy, project_name
+            ))
+
+
+if __name__ == "__main__":
+    # get json exchange data
+    json_path = sys.argv[-1]
+    json_data = open(json_path).read()
+    in_data = json.loads(json_data)
+    out_data = deepcopy(in_data)
+
+    # get main server attributes
+    host_name = in_data.pop("host_name")
+    volume_name = in_data.pop("volume_name")
+    group_name = in_data.pop("group_name")
+
+    # initialize class
+    wiretap_handler = WireTapCom(host_name, volume_name, group_name)
+
+    try:
+        app_args = wiretap_handler.get_launch_args(
+            project_name=in_data.pop("project_name"),
+            project_data=in_data.pop("project_data"),
+            user_name=in_data.pop("user_name"),
+            **in_data
+        )
+    finally:
+        wiretap_handler.close()
+
+    # set returned args back to out data
+    out_data.update({
+        "app_args": app_args
+    })
+
+    # write it out back to the exchange json file
+    with open(json_path, "w") as file_stream:
+        json.dump(out_data, file_stream, indent=4)

openpype/hosts/flame/utility_scripts/openpype_in_flame.py

@@ -0,0 +1,191 @@
+from __future__ import print_function
+import sys
+from Qt import QtWidgets
+from pprint import pformat
+import atexit
+import openpype
+import avalon
+import openpype.hosts.flame as opflame
+
+flh = sys.modules[__name__]
+flh._project = None
+
+
+def openpype_install():
+    """Registering OpenPype in context
+    """
+    openpype.install()
+    avalon.api.install(opflame)
+    print("Avalon registred hosts: {}".format(
+        avalon.api.registered_host()))
+
+
+# Exception handler
+def exeption_handler(exctype, value, _traceback):
+    """Exception handler for improving UX
+
+    Args:
+        exctype (str): type of exception
+        value (str): exception value
+        tb (str): traceback to show
+    """
+    import traceback
+    msg = "OpenPype: Python exception {} in {}".format(value, exctype)
+    mbox = QtWidgets.QMessageBox()
+    mbox.setText(msg)
+    mbox.setDetailedText(
+        pformat(traceback.format_exception(exctype, value, _traceback)))
+    mbox.setStyleSheet('QLabel{min-width: 800px;}')
+    mbox.exec_()
+    sys.__excepthook__(exctype, value, _traceback)
+
+
+# add exception handler into sys module
+sys.excepthook = exeption_handler
+
+
+# register clean up logic to be called at Flame exit
+def cleanup():
+    """Cleaning up Flame framework context
+    """
+    if opflame.apps:
+        print('`{}` cleaning up apps:\n {}\n'.format(
+            __file__, pformat(opflame.apps)))
+        while len(opflame.apps):
+            app = opflame.apps.pop()
+            print('`{}` removing : {}'.format(__file__, app.name))
+            del app
+        opflame.apps = []
+
+    if opflame.app_framework:
+        print('PYTHON\t: %s cleaning up' % opflame.app_framework.bundle_name)
+        opflame.app_framework.save_prefs()
+        opflame.app_framework = None
+
+
+atexit.register(cleanup)
+
+
+def load_apps():
+    """Load available apps into Flame framework
+    """
+    opflame.apps.append(opflame.FlameMenuProjectConnect(opflame.app_framework))
+    opflame.apps.append(opflame.FlameMenuTimeline(opflame.app_framework))
+    opflame.app_framework.log.info("Apps are loaded")
+
+
+def project_changed_dict(info):
+    """Hook for project change action
+
+    Args:
+        info (str): info text
+    """
+    cleanup()
+
+
+def app_initialized(parent=None):
+    """Inicialization of Framework
+
+    Args:
+        parent (obj, optional): Parent object. Defaults to None.
+    """
+    opflame.app_framework = opflame.FlameAppFramework()
+
+    print("{} initializing".format(
+        opflame.app_framework.bundle_name))
+
+    load_apps()
+
+
+"""
+Initialisation of the hook is starting from here
+
+First it needs to test if it can import the flame modul.
+This will happen only in case a project has been loaded.
+Then `app_initialized` will load main Framework which will load
+all menu objects as apps.
+"""
+
+try:
+    import flame  # noqa
+    app_initialized(parent=None)
+except ImportError:
+    print("!!!! not able to import flame module !!!!")
+
+
+def rescan_hooks():
+    import flame  # noqa
+    flame.execute_shortcut('Rescan Python Hooks')
+
+
+def _build_app_menu(app_name):
+    """Flame menu object generator
+
+    Args:
+        app_name (str): name of menu object app
+
+    Returns:
+        list: menu object
+    """
+    menu = []
+
+    # first find the relative appname
+    app = None
+    for _app in opflame.apps:
+        if _app.__class__.__name__ == app_name:
+            app = _app
+
+    if app:
+        menu.append(app.build_menu())
+
+    if opflame.app_framework:
+        menu_auto_refresh = opflame.app_framework.prefs_global.get(
+            'menu_auto_refresh', {})
+        if menu_auto_refresh.get('timeline_menu', True):
+            try:
+                import flame  # noqa
+                flame.schedule_idle_event(rescan_hooks)
+            except ImportError:
+                print("!-!!! not able to import flame module !!!!")
+
+    return menu
+
+
+""" Flame hooks are starting here
+"""
+
+
+def project_saved(project_name, save_time, is_auto_save):
+    """Hook to activate when project is saved
+
+    Args:
+        project_name (str): name of project
+        save_time (str): time when it was saved
+        is_auto_save (bool): autosave is on or off
+    """
+    if opflame.app_framework:
+        opflame.app_framework.save_prefs()
+
+
+def get_main_menu_custom_ui_actions():
+    """Hook to create submenu in start menu
+
+    Returns:
+        list: menu object
+    """
+    # install openpype and the host
+    openpype_install()
+
+    return _build_app_menu("FlameMenuProjectConnect")
+
+
+def get_timeline_custom_ui_actions():
+    """Hook to create submenu in timeline
+
+    Returns:
+        list: menu object
+    """
+    # install openpype and the host
+    openpype_install()
+
+    return _build_app_menu("FlameMenuTimeline")

openpype/lib/local_settings.py

@@ -522,6 +522,11 @@ def get_local_site_id():
 
     Identifier is created if does not exists yet.
     """
+    # override local id from environment
+    # used for background syncing
+    if os.environ.get("SITE_SYNC_LOCAL_ID"):
+        return os.environ["SITE_SYNC_LOCAL_ID"]
+
     registry = OpenPypeSettingsRegistry()
     try:
         return registry.get_item("localId")

openpype/modules/default_modules/sync_server/providers/local_drive.py

@@ -84,6 +84,7 @@ class LocalDriveHandler(AbstractProvider):
         if not os.path.isfile(source_path):
             raise FileNotFoundError("Source file {} doesn't exist."
                                     .format(source_path))
+
         if overwrite:
             thread = threading.Thread(target=self._copy,
                                       args=(source_path, target_path))
@@ -176,7 +177,10 @@ class LocalDriveHandler(AbstractProvider):
 
     def _copy(self, source_path, target_path):
         print("copying {}->{}".format(source_path, target_path))
-        shutil.copy(source_path, target_path)
+        try:
+            shutil.copy(source_path, target_path)
+        except shutil.SameFileError:
+            print("same files, skipping")
 
     def _mark_progress(self, collection, file, representation, server, site,
                        source_path, target_path, direction):

openpype/modules/default_modules/sync_server/sync_server.py

@@ -246,6 +246,7 @@ class SyncServerThread(threading.Thread):
 
             asyncio.ensure_future(self.check_shutdown(), loop=self.loop)
             asyncio.ensure_future(self.sync_loop(), loop=self.loop)
+            log.info("Sync Server Started")
             self.loop.run_forever()
         except Exception:
             log.warning(

openpype/modules/default_modules/sync_server/sync_server_module.py

@@ -152,9 +152,9 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
         if not site_name:
             site_name = self.DEFAULT_SITE
 
-        self.reset_provider_for_file(collection,
-                                     representation_id,
-                                     site_name=site_name, force=force)
+        self.reset_site_on_representation(collection,
+                                          representation_id,
+                                          site_name=site_name, force=force)
 
     # public facing API
     def remove_site(self, collection, representation_id, site_name,
@@ -176,10 +176,10 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
         if not self.get_sync_project_setting(collection):
             raise ValueError("Project not configured")
 
-        self.reset_provider_for_file(collection,
-                                     representation_id,
-                                     site_name=site_name,
-                                     remove=True)
+        self.reset_site_on_representation(collection,
+                                          representation_id,
+                                          site_name=site_name,
+                                          remove=True)
         if remove_local_files:
             self._remove_local_file(collection, representation_id, site_name)
 
@@ -314,8 +314,8 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
         """
         log.info("Pausing SyncServer for {}".format(representation_id))
         self._paused_representations.add(representation_id)
-        self.reset_provider_for_file(collection, representation_id,
-                                     site_name=site_name, pause=True)
+        self.reset_site_on_representation(collection, representation_id,
+                                          site_name=site_name, pause=True)
 
     def unpause_representation(self, collection, representation_id, site_name):
         """
@@ -334,8 +334,8 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
         except KeyError:
             pass
         # self.paused_representations is not persistent
-        self.reset_provider_for_file(collection, representation_id,
-                                     site_name=site_name, pause=False)
+        self.reset_site_on_representation(collection, representation_id,
+                                          site_name=site_name, pause=False)
 
     def is_representation_paused(self, representation_id,
                                  check_parents=False, project_name=None):
@@ -799,12 +799,19 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
 
     def tray_init(self):
         """
-            Actual initialization of Sync Server.
+            Actual initialization of Sync Server for Tray.
 
             Called when tray is initialized, it checks if module should be
             enabled. If not, no initialization necessary.
         """
-        # import only in tray, because of Python2 hosts
+        self.server_init()
+
+        from .tray.app import SyncServerWindow
+        self.widget = SyncServerWindow(self)
+
+    def server_init(self):
+        """Actual initialization of Sync Server."""
+        # import only in tray or Python3, because of Python2 hosts
         from .sync_server import SyncServerThread
 
         if not self.enabled:
@@ -816,7 +823,20 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
             return
 
         self.lock = threading.Lock()
-        self.sync_server_thread = SyncServerThread(self)
+
+        try:
+            self.sync_server_thread = SyncServerThread(self)
+
+        except ValueError:
+            log.info("No system setting for sync. Not syncing.", exc_info=True)
+            self.enabled = False
+        except KeyError:
+            log.info((
+                     "There are not set presets for SyncServer OR "
+                     "Credentials provided are invalid, "
+                     "no syncing possible").
+                     format(str(self.sync_project_settings)), exc_info=True)
+            self.enabled = False
 
     def tray_start(self):
         """
@@ -829,6 +849,9 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
         Returns:
             None
         """
+        self.server_start()
+
+    def server_start(self):
         if self.sync_project_settings and self.enabled:
             self.sync_server_thread.start()
         else:
@@ -841,6 +864,9 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
 
             Called from Module Manager
         """
+        self.server_exit()
+
+    def server_exit(self):
         if not self.sync_server_thread:
             return
 
@@ -850,6 +876,7 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
             log.info("Stopping sync server server")
             self.sync_server_thread.is_running = False
             self.sync_server_thread.stop()
+            log.info("Sync server stopped")
         except Exception:
             log.warning(
                 "Error has happened during Killing sync server",
@@ -1319,9 +1346,9 @@ class SyncServerModule(OpenPypeModule, ITrayModule):
 
         return -1, None
 
-    def reset_provider_for_file(self, collection, representation_id,
-                                side=None, file_id=None, site_name=None,
-                                remove=False, pause=None, force=False):
+    def reset_site_on_representation(self, collection, representation_id,
+                                     side=None, file_id=None, site_name=None,
+                                     remove=False, pause=None, force=False):
         """
             Reset information about synchronization for particular 'file_id'
             and provider.

openpype/modules/default_modules/sync_server/tray/widgets.py

@@ -469,7 +469,7 @@ class _SyncRepresentationWidget(QtWidgets.QWidget):
                           format(check_progress))
                 continue
 
-            self.sync_server.reset_provider_for_file(
+            self.sync_server.reset_site_on_representation(
                 self.model.project,
                 representation_id,
                 site_name=site_name,
@@ -844,7 +844,7 @@ class SyncRepresentationDetailWidget(_SyncRepresentationWidget):
                           format(check_progress))
                 continue
 
-            self.sync_server.reset_provider_for_file(
+            self.sync_server.reset_site_on_representation(
                 self.model.project,
                 self.representation_id,
                 site_name=site_name,

openpype/plugins/publish/integrate_new.py

@@ -1028,6 +1028,7 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
         """
         local_site = 'studio'  # default
         remote_site = None
+        always_accesible = []
         sync_server_presets = None
 
         if (instance.context.data["system_settings"]
@@ -1042,6 +1043,8 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
             if sync_server_presets["enabled"]:
                 local_site = sync_server_presets["config"].\
                     get("active_site", "studio").strip()
+                always_accesible = sync_server_presets["config"].\
+                    get("always_accessible_on", [])
                 if local_site == 'local':
                     local_site = local_site_id
 
@@ -1072,6 +1075,12 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
                 meta = {"name": remote_site.strip()}
                 rec["sites"].append(meta)
 
+            # add skeleton for site where it should be always synced to
+            for always_on_site in always_accesible:
+                if always_on_site not in [local_site, remote_site]:
+                    meta = {"name": always_on_site.strip()}
+                    rec["sites"].append(meta)
+
         return rec
 
     def handle_destination_files(self, integrated_file_sizes, mode):

openpype/pype_commands.py

@@ -3,7 +3,6 @@
 import os
 import sys
 import json
-from datetime import datetime
 import time
 
 from openpype.lib import PypeLogger
@@ -329,3 +328,28 @@ class PypeCommands:
         cmd = "pytest {} {} {}".format(folder, mark_str, pyargs_str)
         print("Running {}".format(cmd))
         subprocess.run(cmd)
+
+    def syncserver(self, active_site):
+        """Start running sync_server in background."""
+        import signal
+        os.environ["SITE_SYNC_LOCAL_ID"] = active_site
+
+        def signal_handler(sig, frame):
+            print("You pressed Ctrl+C. Process ended.")
+            sync_server_module.server_exit()
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, signal_handler)
+        signal.signal(signal.SIGTERM, signal_handler)
+
+        from openpype.modules import ModulesManager
+
+        manager = ModulesManager()
+        sync_server_module = manager.modules_by_name["sync_server"]
+
+        sync_server_module.server_init()
+        sync_server_module.server_start()
+
+        import time
+        while True:
+            time.sleep(1.0)

openpype/settings/defaults/project_settings/global.json

@@ -319,6 +319,7 @@
         "config": {
             "retry_cnt": "3",
             "loop_delay": "60",
+            "always_accessible_on": [],
             "active_site": "studio",
             "remote_site": "studio"
         },

openpype/settings/defaults/system_settings/applications.json

@@ -97,6 +97,42 @@
             }
         }
     },
+    "flame": {
+        "enabled": true,
+        "label": "Flame",
+        "icon": "{}/app_icons/flame.png",
+        "host_name": "flame",
+        "environment": {
+            "FLAME_SCRIPT_DIRS": {
+                "windows": "",
+                "darwin": "",
+                "linux": ""
+            }
+        },
+        "variants": {
+            "2021": {
+                "use_python_2": true,
+                "executables": {
+                    "windows": [],
+                    "darwin": [
+                        "/opt/Autodesk/flame_2021/bin/flame.app/Contents/MacOS/startApp"
+                    ],
+                    "linux": [
+                        "/opt/Autodesk/flame_2021/bin/flame"
+                    ]
+                },
+                "arguments": {
+                    "windows": [],
+                    "darwin": [],
+                    "linux": []
+                },
+                "environment": {}
+            },
+            "__dynamic_keys_labels__": {
+                "2021": "2021 (Testing Only)"
+            }
+        }
+    },
     "nuke": {
         "enabled": true,
         "label": "Nuke",
@@ -620,12 +656,12 @@
             "FUSION_UTILITY_SCRIPTS_SOURCE_DIR": [],
             "FUSION_UTILITY_SCRIPTS_DIR": {
                 "windows": "{PROGRAMDATA}/Blackmagic Design/Fusion/Scripts/Comp",
-                "darvin": "/Library/Application Support/Blackmagic Design/Fusion/Scripts/Comp",
+                "darwin": "/Library/Application Support/Blackmagic Design/Fusion/Scripts/Comp",
                 "linux": "/opt/Fusion/Scripts/Comp"
             },
             "PYTHON36": {
                 "windows": "{LOCALAPPDATA}/Programs/Python/Python36",
-                "darvin": "~/Library/Python/3.6/bin",
+                "darwin": "~/Library/Python/3.6/bin",
                 "linux": "/opt/Python/3.6/bin"
             },
             "PYTHONPATH": [
@@ -686,22 +722,22 @@
             "RESOLVE_UTILITY_SCRIPTS_SOURCE_DIR": [],
             "RESOLVE_SCRIPT_API": {
                 "windows": "{PROGRAMDATA}/Blackmagic Design/DaVinci Resolve/Support/Developer/Scripting",
-                "darvin": "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting",
+                "darwin": "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Developer/Scripting",
                 "linux": "/opt/resolve/Developer/Scripting"
             },
             "RESOLVE_SCRIPT_LIB": {
                 "windows": "C:/Program Files/Blackmagic Design/DaVinci Resolve/fusionscript.dll",
-                "darvin": "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so",
+                "darwin": "/Applications/DaVinci Resolve/DaVinci Resolve.app/Contents/Libraries/Fusion/fusionscript.so",
                 "linux": "/opt/resolve/libs/Fusion/fusionscript.so"
             },
             "RESOLVE_UTILITY_SCRIPTS_DIR": {
                 "windows": "{PROGRAMDATA}/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Comp",
-                "darvin": "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Comp",
+                "darwin": "/Library/Application Support/Blackmagic Design/DaVinci Resolve/Fusion/Scripts/Comp",
                 "linux": "/opt/resolve/Fusion/Scripts/Comp"
             },
             "PYTHON36_RESOLVE": {
                 "windows": "{LOCALAPPDATA}/Programs/Python/Python36",
-                "darvin": "~/Library/Python/3.6/bin",
+                "darwin": "~/Library/Python/3.6/bin",
                 "linux": "/opt/Python/3.6/bin"
             },
             "PYTHONPATH": [

openpype/settings/entities/enum_entity.py

@@ -143,6 +143,7 @@ class HostsEnumEntity(BaseEnumEntity):
         "aftereffects",
         "blender",
         "celaction",
+        "flame",
         "fusion",
         "harmony",
         "hiero",

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

@@ -26,15 +26,24 @@
                     "key": "loop_delay",
                     "label": "Loop Delay"
                 },
+                {
+                    "type": "list",
+                    "key": "always_accessible_on",
+                    "label": "Always accessible on sites",
+                    "object_type": "text"
+                },
+                {
+                    "type": "splitter"
+                },
                 {
                     "type": "text",
                     "key": "active_site",
-                    "label": "Active Site"
+                    "label": "User Default Active Site"
                 },
                 {
                     "type": "text",
                     "key": "remote_site",
-                    "label": "Remote Site"
+                    "label": "User Default Remote Site"
                 }
             ]
         },

openpype/settings/entities/schemas/system_schema/host_settings/schema_flame.json

@@ -0,0 +1,39 @@
+{
+    "type": "dict",
+    "key": "flame",
+    "label": "Autodesk Flame",
+    "collapsible": true,
+    "checkbox_key": "enabled",
+    "children": [
+        {
+            "type": "boolean",
+            "key": "enabled",
+            "label": "Enabled"
+        },
+        {
+            "type": "schema_template",
+            "name": "template_host_unchangables"
+        },
+        {
+            "key": "environment",
+            "label": "Environment",
+            "type": "raw-json"
+        },
+        {
+            "type": "dict-modifiable",
+            "key": "variants",
+            "collapsible_key": true,
+            "use_label_wrap": false,
+            "object_type": {
+                "type": "dict",
+                "collapsible": true,
+                "children": [
+                    {
+                        "type": "schema_template",
+                        "name": "template_host_variant_items"
+                    }
+                ]
+            }
+        }
+    ]
+}

openpype/settings/entities/schemas/system_schema/schema_applications.json

@@ -9,6 +9,10 @@
       "type": "schema",
       "name": "schema_maya"
     },
+    {
+      "type": "schema",
+      "name": "schema_flame"
+    },
     {
       "type": "schema_template",
       "name": "template_nuke",

openpype/version.py

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

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "OpenPype"
-version = "3.5.1-nightly.1" # OpenPype
+version = "3.6.0-nightly.1" # OpenPype
 description = "Open VFX and Animation pipeline with support."
 authors = ["OpenPype Team <info@openpype.io>"]
 license = "MIT License"

website/docs/module_site_sync.md

@@ -140,3 +140,42 @@ Beware that ssh key expects OpenSSH format (`.pem`) not a Putty format (`.ppk`)!
 
 If a studio needs to use other services for cloud storage, or want to implement totally different storage providers, they can do so by writing their own provider plugin. We're working on a developer documentation, however, for now we recommend looking at `abstract_provider.py`and `gdrive.py` inside `openpype/modules/sync_server/providers` and using it as a template.
 
+### Running Site Sync in background
+
+Site Sync server synchronizes new published files from artist machine into configured remote location by default.
+
+There might be a use case where you need to synchronize between "non-artist" sites, for example between studio site and cloud. In this case
+you need to run Site Sync as a background process from a command line (via service etc) 24/7.
+
+To configure all sites where all published files should be synced eventually you need to configure `project_settings/global/sync_server/config/always_accessible_on` property in Settins (per project) first.
+
+![Set another non artist remote site](assets/site_sync_always_on.png)
+
+This is an example of:
+- Site Sync is enabled for a project
+- default active and remote sites are set to `studio` - eg. standard process: everyone is working in a studio, publishing to shared location etc.
+- (but this also allows any of the artists to work remotely, they would change their active site in their own Local Settings to `local` and configure local root.
+  This would result in everything artist publishes is saved first onto his local folder AND synchronized to `studio` site eventually.)
+- everything exported must also be eventually uploaded to `sftp` site
+
+This eventual synchronization between `studio` and `sftp` sites must be physically handled by background process.
+
+As current implementation relies heavily on Settings and Local Settings, background process for a specific site ('studio' for example) must be configured via Tray first to `syncserver` command to work.
+
+To do this:
+
+- run OP `Tray` with environment variable SITE_SYNC_LOCAL_ID set to name of active (source) site. In most use cases it would be studio (for cases of backups of everything published to studio site to different cloud site etc.)
+- start `Tray`
+- check `Local ID` in information dialog after clicking on version number in the Tray
+- open `Local Settings` in the `Tray`
+- configure for each project necessary active site and remote site
+- close `Tray`
+- run OP from a command line with `syncserver` and `--active_site` arguments
+
+
+This is an example how to trigger background synching process where active (source) site is `studio`. 
+(It is expected that OP is installed on a machine, `openpype_console` is on PATH. If not, add full path to executable.
+)
+```shell
+openpype_console syncserver --active_site studio
+```