diff --git a/client/ayon_core/hosts/fusion/api/action.py b/client/ayon_core/hosts/fusion/api/action.py
index 1643f1ce03..a0c6aafcb5 100644
--- a/client/ayon_core/hosts/fusion/api/action.py
+++ b/client/ayon_core/hosts/fusion/api/action.py
@@ -58,3 +58,55 @@ class SelectInvalidAction(pyblish.api.Action):
         self.log.info(
             "Selecting invalid tools: %s" % ", ".join(sorted(names))
         )
+
+
+class SelectToolAction(pyblish.api.Action):
+    """Select invalid output tool in Fusion when plug-in failed.
+
+    """
+
+    label = "Select saver"
+    on = "failed"  # This action is only available on a failed plug-in
+    icon = "search"  # Icon from Awesome Icon
+
+    def process(self, context, plugin):
+        errored_instances = get_errored_instances_from_context(
+            context,
+            plugin=plugin,
+        )
+
+        # Get the invalid nodes for the plug-ins
+        self.log.info("Finding invalid nodes..")
+        tools = []
+        for instance in errored_instances:
+
+            tool = instance.data.get("tool")
+            if tool is not None:
+                tools.append(tool)
+            else:
+                self.log.warning(
+                    "Plug-in returned to be invalid, "
+                    f"but has no saver for instance {instance.name}."
+                )
+
+        if not tools:
+            # Assume relevant comp is current comp and clear selection
+            self.log.info("No invalid tools found.")
+            comp = get_current_comp()
+            flow = comp.CurrentFrame.FlowView
+            flow.Select()  # No args equals clearing selection
+            return
+
+        # Assume a single comp
+        first_tool = tools[0]
+        comp = first_tool.Comp()
+        flow = comp.CurrentFrame.FlowView
+        flow.Select()  # No args equals clearing selection
+        names = set()
+        for tool in tools:
+            flow.Select(tool, True)
+            comp.SetActiveTool(tool)
+            names.add(tool.Name)
+        self.log.info(
+            "Selecting invalid tools: %s" % ", ".join(sorted(names))
+        )
diff --git a/client/ayon_core/hosts/fusion/plugins/publish/collect_render.py b/client/ayon_core/hosts/fusion/plugins/publish/collect_render.py
index 95d029aad4..9c04e59717 100644
--- a/client/ayon_core/hosts/fusion/plugins/publish/collect_render.py
+++ b/client/ayon_core/hosts/fusion/plugins/publish/collect_render.py
@@ -52,7 +52,7 @@ class CollectFusionRender(
             if product_type not in ["render", "image"]:
                 continue
 
-            task_name = context.data["task"]
+            task_name = inst.data["task"]
             tool = inst.data["transientData"]["tool"]
 
             instance_families = inst.data.get("families", [])
diff --git a/client/ayon_core/hosts/fusion/plugins/publish/validate_instance_in_context.py b/client/ayon_core/hosts/fusion/plugins/publish/validate_instance_in_context.py
new file mode 100644
index 0000000000..3aa6fb452f
--- /dev/null
+++ b/client/ayon_core/hosts/fusion/plugins/publish/validate_instance_in_context.py
@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+"""Validate if instance context is the same as publish context."""
+
+import pyblish.api
+from ayon_core.hosts.fusion.api.action import SelectToolAction
+from ayon_core.pipeline.publish import (
+    RepairAction,
+    ValidateContentsOrder,
+    PublishValidationError,
+    OptionalPyblishPluginMixin
+)
+
+
+class ValidateInstanceInContextFusion(pyblish.api.InstancePlugin,
+                                      OptionalPyblishPluginMixin):
+    """Validator to check if instance context matches context of publish.
+
+    When working in per-shot style you always publish data in context of
+    current asset (shot). This validator checks if this is so. It is optional
+    so it can be disabled when needed.
+    """
+    # Similar to maya and houdini-equivalent `ValidateInstanceInContext`
+
+    order = ValidateContentsOrder
+    label = "Instance in same Context"
+    optional = True
+    hosts = ["fusion"]
+    actions = [SelectToolAction, RepairAction]
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+
+        instance_context = self.get_context(instance.data)
+        context = self.get_context(instance.context.data)
+        if instance_context != context:
+            context_label = "{} > {}".format(*context)
+            instance_label = "{} > {}".format(*instance_context)
+
+            raise PublishValidationError(
+                message=(
+                    "Instance '{}' publishes to different asset than current "
+                    "context: {}. Current context: {}".format(
+                        instance.name, instance_label, context_label
+                    )
+                ),
+                description=(
+                    "## Publishing to a different asset\n"
+                    "There are publish instances present which are publishing "
+                    "into a different asset than your current context.\n\n"
+                    "Usually this is not what you want but there can be cases "
+                    "where you might want to publish into another asset or "
+                    "shot. If that's the case you can disable the validation "
+                    "on the instance to ignore it."
+                )
+            )
+
+    @classmethod
+    def repair(cls, instance):
+
+        create_context = instance.context.data["create_context"]
+        instance_id = instance.data.get("instance_id")
+        created_instance = create_context.get_instance_by_id(
+            instance_id
+        )
+        if created_instance is None:
+            raise RuntimeError(
+                f"No CreatedInstances found with id '{instance_id} "
+                f"in {create_context.instances_by_id}"
+            )
+
+        context_asset, context_task = cls.get_context(instance.context.data)
+        created_instance["folderPath"] = context_asset
+        created_instance["task"] = context_task
+        create_context.save_changes()
+
+    @staticmethod
+    def get_context(data):
+        """Return asset, task from publishing context data"""
+        return data["folderPath"], data["task"]
diff --git a/client/ayon_core/hosts/nuke/api/plugin.py b/client/ayon_core/hosts/nuke/api/plugin.py
index fb56dec833..ec13104d4d 100644
--- a/client/ayon_core/hosts/nuke/api/plugin.py
+++ b/client/ayon_core/hosts/nuke/api/plugin.py
@@ -778,6 +778,7 @@ class ExporterReviewMov(ExporterReview):
         # deal with now lut defined in viewer lut
         self.viewer_lut_raw = klass.viewer_lut_raw
         self.write_colorspace = instance.data["colorspace"]
+        self.color_channels = instance.data["color_channels"]
 
         self.name = name or "baked"
         self.ext = ext or "mov"
@@ -834,7 +835,7 @@ class ExporterReviewMov(ExporterReview):
         self.log.info("Nodes exported...")
         return path
 
-    def generate_mov(self, farm=False, **kwargs):
+    def generate_mov(self, farm=False, delete=True, **kwargs):
         # colorspace data
         colorspace = None
         # get colorspace settings
@@ -947,6 +948,8 @@ class ExporterReviewMov(ExporterReview):
         self.log.debug("Path: {}".format(self.path))
         write_node["file"].setValue(str(self.path))
         write_node["file_type"].setValue(str(self.ext))
+        write_node["channels"].setValue(str(self.color_channels))
+
         # Knobs `meta_codec` and `mov64_codec` are not available on centos.
         # TODO shouldn't this come from settings on outputs?
         try:
@@ -987,8 +990,13 @@ class ExporterReviewMov(ExporterReview):
             self.render(write_node.name())
 
         # ---------- generate representation data
+        tags = ["review", "need_thumbnail"]
+
+        if delete:
+            tags.append("delete")
+
         self.get_representation_data(
-            tags=["review", "need_thumbnail", "delete"] + add_tags,
+            tags=tags + add_tags,
             custom_tags=add_custom_tags,
             range=True,
             colorspace=colorspace
diff --git a/client/ayon_core/hosts/nuke/plugins/publish/collect_writes.py b/client/ayon_core/hosts/nuke/plugins/publish/collect_writes.py
index 745351dc49..27525bcad1 100644
--- a/client/ayon_core/hosts/nuke/plugins/publish/collect_writes.py
+++ b/client/ayon_core/hosts/nuke/plugins/publish/collect_writes.py
@@ -153,6 +153,9 @@ class CollectNukeWrites(pyblish.api.InstancePlugin,
         # Determine defined file type
         ext = write_node["file_type"].value()
 
+        # determine defined channel type
+        color_channels = write_node["channels"].value()
+
         # get frame range data
         handle_start = instance.context.data["handleStart"]
         handle_end = instance.context.data["handleEnd"]
@@ -172,7 +175,8 @@ class CollectNukeWrites(pyblish.api.InstancePlugin,
             "path": write_file_path,
             "outputDir": output_dir,
             "ext": ext,
-            "colorspace": colorspace
+            "colorspace": colorspace,
+            "color_channels": color_channels
         })
 
         if product_type == "render":
diff --git a/client/ayon_core/hosts/nuke/plugins/publish/extract_review_intermediates.py b/client/ayon_core/hosts/nuke/plugins/publish/extract_review_intermediates.py
index 8d7a3ec311..82c7b6e4c5 100644
--- a/client/ayon_core/hosts/nuke/plugins/publish/extract_review_intermediates.py
+++ b/client/ayon_core/hosts/nuke/plugins/publish/extract_review_intermediates.py
@@ -136,11 +136,16 @@ class ExtractReviewIntermediates(publish.Extractor):
                     self, instance, o_name, o_data["extension"],
                     multiple_presets)
 
+                o_data["add_custom_tags"].append("intermediate")
+                delete = not o_data.get("publish", False)
+
                 if instance.data.get("farm"):
                     if "review" in instance.data["families"]:
                         instance.data["families"].remove("review")
 
-                    data = exporter.generate_mov(farm=True, **o_data)
+                    data = exporter.generate_mov(
+                        farm=True, delete=delete, **o_data
+                    )
 
                     self.log.debug(
                         "_ data: {}".format(data))
@@ -154,7 +159,7 @@ class ExtractReviewIntermediates(publish.Extractor):
                         "bakeWriteNodeName": data.get("bakeWriteNodeName")
                     })
                 else:
-                    data = exporter.generate_mov(**o_data)
+                    data = exporter.generate_mov(delete=delete, **o_data)
 
                 # add representation generated by exporter
                 generated_repres.extend(data["representations"])
diff --git a/client/ayon_core/pipeline/colorspace.py b/client/ayon_core/pipeline/colorspace.py
index 3503d0c534..239c187959 100644
--- a/client/ayon_core/pipeline/colorspace.py
+++ b/client/ayon_core/pipeline/colorspace.py
@@ -18,11 +18,10 @@ from ayon_core.lib import (
     run_ayon_launcher_process,
     Logger,
 )
+from ayon_core.lib.transcoding import VIDEO_EXTENSIONS, IMAGE_EXTENSIONS
 from ayon_core.pipeline import Anatomy
 from ayon_core.pipeline.template_data import get_template_data
 from ayon_core.pipeline.load import get_representation_path_with_anatomy
-from ayon_core.lib.transcoding import VIDEO_EXTENSIONS, IMAGE_EXTENSIONS
-
 
 log = Logger.get_logger(__name__)
 
@@ -37,10 +36,6 @@ class CachedData:
     }
 
 
-class DeprecatedWarning(DeprecationWarning):
-    pass
-
-
 def deprecated(new_destination):
     """Mark functions as deprecated.
 
@@ -65,13 +60,13 @@ def deprecated(new_destination):
 
         @functools.wraps(decorated_func)
         def wrapper(*args, **kwargs):
-            warnings.simplefilter("always", DeprecatedWarning)
+            warnings.simplefilter("always", DeprecationWarning)
             warnings.warn(
                 (
                     "Call to deprecated function '{}'"
                     "\nFunction was moved or removed.{}"
                 ).format(decorated_func.__name__, warning_message),
-                category=DeprecatedWarning,
+                category=DeprecationWarning,
                 stacklevel=4
             )
             return decorated_func(*args, **kwargs)
@@ -107,6 +102,35 @@ def _make_temp_json_file():
             os.remove(temporary_json_filepath)
 
 
+def has_compatible_ocio_package():
+    """Current process has available compatible 'PyOpenColorIO'.
+
+    Returns:
+        bool: True if compatible package is available.
+
+    """
+    if CachedData.has_compatible_ocio_package is not None:
+        return CachedData.has_compatible_ocio_package
+
+    is_compatible = False
+    try:
+        import PyOpenColorIO
+
+        # Check if PyOpenColorIO is compatible
+        # - version 2.0.0 or higher is required
+        # NOTE version 1 does not have '__version__' attribute
+        if hasattr(PyOpenColorIO, "__version__"):
+            version_parts = PyOpenColorIO.__version__.split(".")
+            major = int(version_parts[0])
+            is_compatible = (major, ) >= (2, )
+    except ImportError:
+        pass
+
+    CachedData.has_compatible_ocio_package = is_compatible
+    # compatible
+    return CachedData.has_compatible_ocio_package
+
+
 def get_ocio_config_script_path():
     """Get path to ocio wrapper script
 
@@ -195,17 +219,6 @@ def get_colorspace_name_from_filepath(
     return colorspace_name
 
 
-# TODO: remove this in future - backward compatibility
-@deprecated("get_imageio_file_rules_colorspace_from_filepath")
-def get_imageio_colorspace_from_filepath(*args, **kwargs):
-    return get_imageio_file_rules_colorspace_from_filepath(*args, **kwargs)
-
-# TODO: remove this in future - backward compatibility
-@deprecated("get_imageio_file_rules_colorspace_from_filepath")
-def get_colorspace_from_filepath(*args, **kwargs):
-    return get_imageio_file_rules_colorspace_from_filepath(*args, **kwargs)
-
-
 def get_imageio_file_rules_colorspace_from_filepath(
     filepath,
     host_name,
@@ -271,26 +284,48 @@ def get_config_file_rules_colorspace_from_filepath(config_path, filepath):
 
     Returns:
         Union[str, None]: matching colorspace name
+
     """
-    if not compatibility_check():
-        # python environment is not compatible with PyOpenColorIO
-        # needs to be run in subprocess
+    if has_compatible_ocio_package():
+        result_data = _get_config_file_rules_colorspace_from_filepath(
+            config_path, filepath
+        )
+    else:
         result_data = _get_wrapped_with_subprocess(
-            "colorspace", "get_config_file_rules_colorspace_from_filepath",
+            "get_config_file_rules_colorspace_from_filepath",
             config_path=config_path,
             filepath=filepath
         )
-        if result_data:
-            return result_data[0]
-
-    # TODO: refactor this so it is not imported but part of this file
-    from ayon_core.scripts.ocio_wrapper import _get_config_file_rules_colorspace_from_filepath  # noqa: E501
-
-    result_data = _get_config_file_rules_colorspace_from_filepath(
-        config_path, filepath)
 
     if result_data:
         return result_data[0]
+    return None
+
+
+def get_config_version_data(config_path):
+    """Return major and minor version info.
+
+    Args:
+        config_path (str): path string leading to config.ocio
+
+    Raises:
+        IOError: Input config does not exist.
+
+    Returns:
+        dict: minor and major keys with values
+
+    """
+    if config_path not in CachedData.config_version_data:
+        if has_compatible_ocio_package():
+            version_data = _get_config_version_data(config_path)
+        else:
+            version_data = _get_wrapped_with_subprocess(
+                "get_config_version_data",
+                config_path=config_path
+            )
+        CachedData.config_version_data[config_path] = version_data
+
+    return deepcopy(CachedData.config_version_data[config_path])
 
 
 def parse_colorspace_from_filepath(
@@ -384,6 +419,7 @@ def validate_imageio_colorspace_in_config(config_path, colorspace_name):
 
     Returns:
         bool: True if exists
+
     """
     colorspaces = get_ocio_config_colorspaces(config_path)["colorspaces"]
     if colorspace_name not in colorspaces:
@@ -394,28 +430,10 @@ def validate_imageio_colorspace_in_config(config_path, colorspace_name):
     return True
 
 
-# TODO: remove this in future - backward compatibility
-@deprecated("_get_wrapped_with_subprocess")
-def get_data_subprocess(config_path, data_type):
-    """[Deprecated] Get data via subprocess
-
-    Wrapper for Python 2 hosts.
+def _get_wrapped_with_subprocess(command, **kwargs):
+    """Get data via subprocess.
 
     Args:
-        config_path (str): path leading to config.ocio file
-    """
-    return _get_wrapped_with_subprocess(
-        "config", data_type, in_path=config_path,
-    )
-
-
-def _get_wrapped_with_subprocess(command_group, command, **kwargs):
-    """Get data via subprocess
-
-    Wrapper for Python 2 hosts.
-
-    Args:
-        command_group (str): command group name
         command (str): command name
         **kwargs: command arguments
 
@@ -425,14 +443,15 @@ def _get_wrapped_with_subprocess(command_group, command, **kwargs):
     with _make_temp_json_file() as tmp_json_path:
         # Prepare subprocess arguments
         args = [
-            "run", get_ocio_config_script_path(),
-            command_group, command
+            "run",
+            get_ocio_config_script_path(),
+            command
         ]
 
-        for key_, value_ in kwargs.items():
-            args.extend(("--{}".format(key_), value_))
+        for key, value in kwargs.items():
+            args.extend(("--{}".format(key), value))
 
-        args.append("--out_path")
+        args.append("--output_path")
         args.append(tmp_json_path)
 
         log.info("Executing: {}".format(" ".join(args)))
@@ -440,55 +459,23 @@ def _get_wrapped_with_subprocess(command_group, command, **kwargs):
         run_ayon_launcher_process(*args, logger=log)
 
         # return all colorspaces
-        with open(tmp_json_path, "r") as f_:
-            return json.load(f_)
+        with open(tmp_json_path, "r") as stream:
+            return json.load(stream)
 
 
-# TODO: this should be part of ocio_wrapper.py
-def compatibility_check():
-    """Making sure PyOpenColorIO is importable"""
-    if CachedData.has_compatible_ocio_package is not None:
-        return CachedData.has_compatible_ocio_package
-
-    try:
-        import PyOpenColorIO  # noqa: F401
-        CachedData.has_compatible_ocio_package = True
-    except ImportError:
-        CachedData.has_compatible_ocio_package = False
-
-    # compatible
-    return CachedData.has_compatible_ocio_package
-
-
-# TODO: this should be part of ocio_wrapper.py
 def compatibility_check_config_version(config_path, major=1, minor=None):
     """Making sure PyOpenColorIO config version is compatible"""
 
-    if not CachedData.config_version_data.get(config_path):
-        if compatibility_check():
-            # TODO: refactor this so it is not imported but part of this file
-            from ayon_core.scripts.ocio_wrapper import _get_version_data
-
-            CachedData.config_version_data[config_path] = \
-                _get_version_data(config_path)
-
-        else:
-            # python environment is not compatible with PyOpenColorIO
-            # needs to be run in subprocess
-            CachedData.config_version_data[config_path] = \
-                _get_wrapped_with_subprocess(
-                    "config", "get_version", config_path=config_path
-            )
+    version_data = get_config_version_data(config_path)
 
     # check major version
-    if CachedData.config_version_data[config_path]["major"] != major:
+    if version_data["major"] != major:
         return False
 
     # check minor version
-    if minor and CachedData.config_version_data[config_path]["minor"] != minor:
+    if minor is not None and version_data["minor"] != minor:
         return False
 
-    # compatible
     return True
 
 
@@ -503,22 +490,19 @@ def get_ocio_config_colorspaces(config_path):
 
     Returns:
         dict: colorspace and family in couple
-    """
-    if not CachedData.ocio_config_colorspaces.get(config_path):
-        if not compatibility_check():
-            # python environment is not compatible with PyOpenColorIO
-            # needs to be run in subprocess
-            config_colorspaces = _get_wrapped_with_subprocess(
-                "config", "get_colorspace", in_path=config_path
-            )
-        else:
-            # TODO: refactor this so it is not imported but part of this file
-            from ayon_core.scripts.ocio_wrapper import _get_colorspace_data
 
-            config_colorspaces = _get_colorspace_data(config_path)
+    """
+    if config_path not in CachedData.ocio_config_colorspaces:
+        if has_compatible_ocio_package():
+            config_colorspaces = _get_ocio_config_colorspaces(config_path)
+        else:
+            config_colorspaces = _get_wrapped_with_subprocess(
+                "get_ocio_config_colorspaces",
+                config_path=config_path
+            )
         CachedData.ocio_config_colorspaces[config_path] = config_colorspaces
 
-    return CachedData.ocio_config_colorspaces[config_path]
+    return deepcopy(CachedData.ocio_config_colorspaces[config_path])
 
 
 def convert_colorspace_enumerator_item(
@@ -592,16 +576,18 @@ def get_colorspaces_enumerator_items(
     Families can be used for building menu and submenus in gui.
 
     Args:
-        config_items (dict[str,dict]): colorspace data coming from
-            `get_ocio_config_colorspaces` function
-        include_aliases (bool): include aliases in result
-        include_looks (bool): include looks in result
-        include_roles (bool): include roles in result
+        config_items (dict[str,dict]): Colorspace data coming from
+            `get_ocio_config_colorspaces` function.
+        include_aliases (Optional[bool]): Include aliases in result.
+        include_looks (Optional[bool]): Include looks in result.
+        include_roles (Optional[bool]): Include roles in result.
+        include_display_views (Optional[bool]): Include display views
+            in result.
 
     Returns:
-        list[tuple[str,str]]: colorspace and family in couple
+        list[tuple[str, str]]: Colorspace and family in couples.
+
     """
-    labeled_colorspaces = []
     aliases = set()
     colorspaces = set()
     looks = set()
@@ -611,86 +597,86 @@ def get_colorspaces_enumerator_items(
         if items_type == "colorspaces":
             for color_name, color_data in colorspace_items.items():
                 if color_data.get("aliases"):
-                    aliases.update([
+                    aliases.update({
                         (
                             "aliases::{}".format(alias_name),
                             "[alias] {} ({})".format(alias_name, color_name)
                         )
                         for alias_name in color_data["aliases"]
-                    ])
+                    })
                 colorspaces.add((
                     "{}::{}".format(items_type, color_name),
                     "[colorspace] {}".format(color_name)
                 ))
 
         elif items_type == "looks":
-            looks.update([
+            looks.update({
                 (
                     "{}::{}".format(items_type, name),
                     "[look] {} ({})".format(name, role_data["process_space"])
                 )
                 for name, role_data in colorspace_items.items()
-            ])
+            })
 
         elif items_type == "displays_views":
-            display_views.update([
+            display_views.update({
                 (
                     "{}::{}".format(items_type, name),
                     "[view (display)] {}".format(name)
                 )
                 for name, _ in colorspace_items.items()
-            ])
+            })
 
         elif items_type == "roles":
-            roles.update([
+            roles.update({
                 (
                     "{}::{}".format(items_type, name),
                     "[role] {} ({})".format(name, role_data["colorspace"])
                 )
                 for name, role_data in colorspace_items.items()
-            ])
+            })
 
-    if roles and include_roles:
-        roles = sorted(roles, key=lambda x: x[0])
-        labeled_colorspaces.extend(roles)
+    def _sort_key_getter(item):
+        """Use colorspace for sorting.
 
-    # add colorspaces as second so it is not first in menu
-    colorspaces = sorted(colorspaces, key=lambda x: x[0])
-    labeled_colorspaces.extend(colorspaces)
+        Args:
+            item (tuple[str, str]): Item with colorspace and label.
 
-    if aliases and include_aliases:
-        aliases = sorted(aliases, key=lambda x: x[0])
-        labeled_colorspaces.extend(aliases)
+        Returns:
+            str: Colorspace.
 
-    if looks and include_looks:
-        looks = sorted(looks, key=lambda x: x[0])
-        labeled_colorspaces.extend(looks)
+        """
+        return item[0]
 
-    if display_views and include_display_views:
-        display_views = sorted(display_views, key=lambda x: x[0])
-        labeled_colorspaces.extend(display_views)
+    labeled_colorspaces = []
+    if include_roles:
+        labeled_colorspaces.extend(
+            sorted(roles, key=_sort_key_getter)
+        )
+
+    # Add colorspaces after roles, so it is not first in menu
+    labeled_colorspaces.extend(
+        sorted(colorspaces, key=_sort_key_getter)
+    )
+
+    if include_aliases:
+        labeled_colorspaces.extend(
+            sorted(aliases, key=_sort_key_getter)
+        )
+
+    if include_looks:
+        labeled_colorspaces.extend(
+            sorted(looks, key=_sort_key_getter)
+        )
+
+    if include_display_views:
+        labeled_colorspaces.extend(
+            sorted(display_views, key=_sort_key_getter)
+        )
 
     return labeled_colorspaces
 
 
-# TODO: remove this in future - backward compatibility
-@deprecated("_get_wrapped_with_subprocess")
-def get_colorspace_data_subprocess(config_path):
-    """[Deprecated] Get colorspace data via subprocess
-
-    Wrapper for Python 2 hosts.
-
-    Args:
-        config_path (str): path leading to config.ocio file
-
-    Returns:
-        dict: colorspace and family in couple
-    """
-    return _get_wrapped_with_subprocess(
-        "config", "get_colorspace", in_path=config_path
-    )
-
-
 def get_ocio_config_views(config_path):
     """Get all viewer data
 
@@ -702,82 +688,14 @@ def get_ocio_config_views(config_path):
 
     Returns:
         dict: `display/viewer` and viewer data
+
     """
-    if not compatibility_check():
-        # python environment is not compatible with PyOpenColorIO
-        # needs to be run in subprocess
-        return _get_wrapped_with_subprocess(
-            "config", "get_views", in_path=config_path
-        )
+    if has_compatible_ocio_package():
+        return _get_ocio_config_views(config_path)
 
-    # TODO: refactor this so it is not imported but part of this file
-    from ayon_core.scripts.ocio_wrapper import _get_views_data
-
-    return _get_views_data(config_path)
-
-
-# TODO: remove this in future - backward compatibility
-@deprecated("_get_wrapped_with_subprocess")
-def get_views_data_subprocess(config_path):
-    """[Deprecated] Get viewers data via subprocess
-
-    Wrapper for Python 2 hosts.
-
-    Args:
-        config_path (str): path leading to config.ocio file
-
-    Returns:
-        dict: `display/viewer` and viewer data
-    """
     return _get_wrapped_with_subprocess(
-        "config", "get_views", in_path=config_path
-    )
-
-
-@deprecated("get_imageio_config_preset")
-def get_imageio_config(
-    project_name,
-    host_name,
-    project_settings=None,
-    anatomy_data=None,
-    anatomy=None,
-    env=None
-):
-    """Returns config data from settings
-
-    Config path is formatted in `path` key
-    and original settings input is saved into `template` key.
-
-    Deprecated:
-        Deprecated since '0.3.1' . Use `get_imageio_config_preset` instead.
-
-    Args:
-        project_name (str): project name
-        host_name (str): host name
-        project_settings (Optional[dict]): Project settings.
-        anatomy_data (Optional[dict]): anatomy formatting data.
-        anatomy (Optional[Anatomy]): Anatomy object.
-        env (Optional[dict]): Environment variables.
-
-    Returns:
-        dict: config path data or empty dict
-
-    """
-    if not anatomy_data:
-        from .context_tools import get_current_context_template_data
-        anatomy_data = get_current_context_template_data()
-
-    task_name = anatomy_data.get("task", {}).get("name")
-    folder_path = anatomy_data.get("folder", {}).get("path")
-    return get_imageio_config_preset(
-        project_name,
-        folder_path,
-        task_name,
-        host_name,
-        anatomy=anatomy,
-        project_settings=project_settings,
-        template_data=anatomy_data,
-        env=env,
+        "get_ocio_config_views",
+        config_path=config_path
     )
 
 
@@ -1359,48 +1277,186 @@ def get_display_view_colorspace_name(config_path, display, view):
         str: View color space name. e.g. "Output - sRGB"
 
     """
-    if not compatibility_check():
-        # python environment is not compatible with PyOpenColorIO
-        # needs to be run in subprocess
-        return _get_display_view_colorspace_subprocess(
+    if has_compatible_ocio_package():
+        return _get_display_view_colorspace_name(
             config_path, display, view
         )
-
-    from ayon_core.scripts.ocio_wrapper import _get_display_view_colorspace_name  # noqa
-
-    return _get_display_view_colorspace_name(config_path, display, view)
+    return _get_wrapped_with_subprocess(
+        "get_display_view_colorspace_name",
+        config_path=config_path,
+        display=display,
+        view=view
+    )
 
 
-def _get_display_view_colorspace_subprocess(config_path, display, view):
-    """Returns the colorspace attribute of the (display, view) pair
-        via subprocess.
+# --- Implementation of logic using 'PyOpenColorIO' ---
+def _get_ocio_config(config_path):
+    """Helper function to create OCIO config object.
+
+    Args:
+        config_path (str): Path to config.
+
+    Returns:
+        PyOpenColorIO.Config: OCIO config for the confing path.
+
+    """
+    import PyOpenColorIO
+
+    config_path = os.path.abspath(config_path)
+
+    if not os.path.isfile(config_path):
+        raise IOError("Input path should be `config.ocio` file")
+
+    return PyOpenColorIO.Config.CreateFromFile(config_path)
+
+
+def _get_config_file_rules_colorspace_from_filepath(config_path, filepath):
+    """Return found colorspace data found in v2 file rules.
+
+    Args:
+        config_path (str): path string leading to config.ocio
+        filepath (str): path string leading to v2 file rules
+
+    Raises:
+        IOError: Input config does not exist.
+
+    Returns:
+        dict: aggregated available colorspaces
+
+    """
+    config = _get_ocio_config(config_path)
+
+    # TODO: use `parseColorSpaceFromString` instead if ocio v1
+    return config.getColorSpaceFromFilepath(str(filepath))
+
+
+def _get_config_version_data(config_path):
+    """Return major and minor version info.
+
+    Args:
+        config_path (str): path string leading to config.ocio
+
+    Raises:
+        IOError: Input config does not exist.
+
+    Returns:
+        dict: minor and major keys with values
+
+    """
+    config = _get_ocio_config(config_path)
+
+    return {
+        "major": config.getMajorVersion(),
+        "minor": config.getMinorVersion()
+    }
+
+
+def _get_display_view_colorspace_name(config_path, display, view):
+    """Returns the colorspace attribute of the (display, view) pair.
 
     Args:
         config_path (str): path string leading to config.ocio
         display (str): display name e.g. "ACES"
         view (str): view name e.g. "sRGB"
 
+    Raises:
+        IOError: Input config does not exist.
+
     Returns:
-        view color space name (str) e.g. "Output - sRGB"
+        str: view color space name e.g. "Output - sRGB"
 
     """
-    with _make_temp_json_file() as tmp_json_path:
-        # Prepare subprocess arguments
-        args = [
-            "run", get_ocio_config_script_path(),
-            "config", "get_display_view_colorspace_name",
-            "--in_path", config_path,
-            "--out_path", tmp_json_path,
-            "--display", display,
-            "--view", view
-        ]
-        log.debug("Executing: {}".format(" ".join(args)))
+    config = _get_ocio_config(config_path)
+    return config.getDisplayViewColorSpaceName(display, view)
 
-        run_ayon_launcher_process(*args, logger=log)
 
-        # return default view colorspace name
-        with open(tmp_json_path, "r") as f:
-            return json.load(f)
+def _get_ocio_config_colorspaces(config_path):
+    """Return all found colorspace data.
+
+    Args:
+        config_path (str): path string leading to config.ocio
+
+    Raises:
+        IOError: Input config does not exist.
+
+    Returns:
+        dict: aggregated available colorspaces
+
+    """
+    config = _get_ocio_config(config_path)
+
+    colorspace_data = {
+        "roles": {},
+        "colorspaces": {
+            color.getName(): {
+                "family": color.getFamily(),
+                "categories": list(color.getCategories()),
+                "aliases": list(color.getAliases()),
+                "equalitygroup": color.getEqualityGroup(),
+            }
+            for color in config.getColorSpaces()
+        },
+        "displays_views": {
+            f"{view} ({display})": {
+                "display": display,
+                "view": view
+
+            }
+            for display in config.getDisplays()
+            for view in config.getViews(display)
+        },
+        "looks": {}
+    }
+
+    # add looks
+    looks = config.getLooks()
+    if looks:
+        colorspace_data["looks"] = {
+            look.getName(): {"process_space": look.getProcessSpace()}
+            for look in looks
+        }
+
+    # add roles
+    roles = config.getRoles()
+    if roles:
+        colorspace_data["roles"] = {
+            role: {"colorspace": colorspace}
+            for (role, colorspace) in roles
+        }
+
+    return colorspace_data
+
+
+def _get_ocio_config_views(config_path):
+    """Return all found viewer data.
+
+    Args:
+        config_path (str): path string leading to config.ocio
+
+    Raises:
+        IOError: Input config does not exist.
+
+    Returns:
+        dict: aggregated available viewers
+
+    """
+    config = _get_ocio_config(config_path)
+
+    output = {}
+    for display in config.getDisplays():
+        for view in config.getViews(display):
+            colorspace = config.getDisplayViewColorSpaceName(display, view)
+            # Special token. See https://opencolorio.readthedocs.io/en/latest/guides/authoring/authoring.html#shared-views # noqa
+            if colorspace == "<USE_DISPLAY_NAME>":
+                colorspace = display
+
+            output[f"{display}/{view}"] = {
+                "display": display,
+                "view": view,
+                "colorspace": colorspace
+            }
+
+    return output
 
 
 # --- Current context functions ---
@@ -1437,3 +1493,111 @@ def get_current_context_imageio_config_preset(
         template_data=template_data,
         env=env,
     )
+
+
+# --- Deprecated functions ---
+@deprecated("has_compatible_ocio_package")
+def compatibility_check():
+    """Making sure PyOpenColorIO is importable
+
+    Deprecated:
+        Deprecated since '0.3.2'. Use `has_compatible_ocio_package` instead.
+    """
+
+    return has_compatible_ocio_package()
+
+
+@deprecated("get_imageio_file_rules_colorspace_from_filepath")
+def get_imageio_colorspace_from_filepath(*args, **kwargs):
+    return get_imageio_file_rules_colorspace_from_filepath(*args, **kwargs)
+
+
+@deprecated("get_imageio_file_rules_colorspace_from_filepath")
+def get_colorspace_from_filepath(*args, **kwargs):
+    return get_imageio_file_rules_colorspace_from_filepath(*args, **kwargs)
+
+
+@deprecated("_get_wrapped_with_subprocess")
+def get_colorspace_data_subprocess(config_path):
+    """[Deprecated] Get colorspace data via subprocess
+
+    Deprecated:
+        Deprecated since OpenPype. Use `_get_wrapped_with_subprocess` instead.
+
+    Args:
+        config_path (str): path leading to config.ocio file
+
+    Returns:
+        dict: colorspace and family in couple
+    """
+    return _get_wrapped_with_subprocess(
+        "get_ocio_config_colorspaces",
+        config_path=config_path
+    )
+
+
+@deprecated("_get_wrapped_with_subprocess")
+def get_views_data_subprocess(config_path):
+    """[Deprecated] Get viewers data via subprocess
+
+    Deprecated:
+        Deprecated since OpenPype. Use `_get_wrapped_with_subprocess` instead.
+
+    Args:
+        config_path (str): path leading to config.ocio file
+
+    Returns:
+        dict: `display/viewer` and viewer data
+
+    """
+    return _get_wrapped_with_subprocess(
+        "get_ocio_config_views",
+        config_path=config_path
+    )
+
+
+@deprecated("get_imageio_config_preset")
+def get_imageio_config(
+    project_name,
+    host_name,
+    project_settings=None,
+    anatomy_data=None,
+    anatomy=None,
+    env=None
+):
+    """Returns config data from settings
+
+    Config path is formatted in `path` key
+    and original settings input is saved into `template` key.
+
+    Deprecated:
+        Deprecated since '0.3.1' . Use `get_imageio_config_preset` instead.
+
+    Args:
+        project_name (str): project name
+        host_name (str): host name
+        project_settings (Optional[dict]): Project settings.
+        anatomy_data (Optional[dict]): anatomy formatting data.
+        anatomy (Optional[Anatomy]): Anatomy object.
+        env (Optional[dict]): Environment variables.
+
+    Returns:
+        dict: config path data or empty dict
+
+    """
+    if not anatomy_data:
+        from .context_tools import get_current_context_template_data
+        anatomy_data = get_current_context_template_data()
+
+    task_name = anatomy_data.get("task", {}).get("name")
+    folder_path = anatomy_data.get("folder", {}).get("path")
+    return get_imageio_config_preset(
+        project_name,
+        folder_path,
+        task_name,
+        host_name,
+        anatomy=anatomy,
+        project_settings=project_settings,
+        template_data=anatomy_data,
+        env=env,
+    )
diff --git a/client/ayon_core/scripts/ocio_wrapper.py b/client/ayon_core/scripts/ocio_wrapper.py
index 0a78e33c1f..0414fc59ce 100644
--- a/client/ayon_core/scripts/ocio_wrapper.py
+++ b/client/ayon_core/scripts/ocio_wrapper.py
@@ -1,28 +1,31 @@
 """OpenColorIO Wrapper.
 
-Only to be interpreted by Python 3. It is run in subprocess in case
-Python 2 hosts needs to use it. Or it is used as module for Python 3
-processing.
-
-Providing functionality:
-- get_colorspace - console command - python 2
-                 - returning all available color spaces
-                   found in input config path.
-- _get_colorspace_data - python 3 - module function
-                      - returning all available colorspaces
-                        found in input config path.
-- get_views - console command - python 2
-            - returning all available viewers
-              found in input config path.
-- _get_views_data - python 3 - module function
-                 - returning all available viewers
-                   found in input config path.
+Receive OpenColorIO information and store it in JSON format for processed
+that don't have access to OpenColorIO or their version of OpenColorIO is
+not compatible.
 """
 
-import click
 import json
 from pathlib import Path
-import PyOpenColorIO as ocio
+
+import click
+
+from ayon_core.pipeline.colorspace import (
+    has_compatible_ocio_package,
+    get_display_view_colorspace_name,
+    get_config_file_rules_colorspace_from_filepath,
+    get_config_version_data,
+    get_ocio_config_views,
+    get_ocio_config_colorspaces,
+)
+
+
+def _save_output_to_json_file(output, output_path):
+    json_path = Path(output_path)
+    with open(json_path, "w") as stream:
+        json.dump(output, stream)
+
+    print(f"Data are saved to '{json_path}'")
 
 
 @click.group()
@@ -30,404 +33,185 @@ def main():
     pass  # noqa: WPS100
 
 
-@main.group()
-def config():
-    """Config related commands group
-
-    Example of use:
-    > pyton.exe ./ocio_wrapper.py config <command> *args
-    """
-    pass  # noqa: WPS100
-
-
-@main.group()
-def colorspace():
-    """Colorspace related commands group
-
-    Example of use:
-    > pyton.exe ./ocio_wrapper.py config <command> *args
-    """
-    pass  # noqa: WPS100
-
-
-@config.command(
-    name="get_colorspace",
-    help=(
-        "return all colorspaces from config file "
-        "--path input arg is required"
-    )
-)
-@click.option("--in_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_colorspace(in_path, out_path):
+@main.command(
+    name="get_ocio_config_colorspaces",
+    help="return all colorspaces from config file")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_ocio_config_colorspaces(config_path, output_path):
     """Aggregate all colorspace to file.
 
-    Python 2 wrapped console command
-
     Args:
-        in_path (str): config file path string
-        out_path (str): temp json file path string
+        config_path (str): config file path string
+        output_path (str): temp json file path string
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config get_colorspace
-        --in_path=<path> --out_path=<path>
+        --config_path <path> --output_path <path>
     """
-    json_path = Path(out_path)
-
-    out_data = _get_colorspace_data(in_path)
-
-    with open(json_path, "w") as f_:
-        json.dump(out_data, f_)
-
-    print(f"Colorspace data are saved to '{json_path}'")
-
-
-def _get_colorspace_data(config_path):
-    """Return all found colorspace data.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: aggregated available colorspaces
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError(
-            f"Input path `{config_path}` should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    colorspace_data = {
-        "roles": {},
-        "colorspaces": {
-            color.getName(): {
-                "family": color.getFamily(),
-                "categories": list(color.getCategories()),
-                "aliases": list(color.getAliases()),
-                "equalitygroup": color.getEqualityGroup(),
-            }
-            for color in config.getColorSpaces()
-        },
-        "displays_views": {
-            f"{view} ({display})": {
-                "display": display,
-                "view": view
-
-            }
-            for display in config.getDisplays()
-            for view in config.getViews(display)
-        },
-        "looks": {}
-    }
-
-    # add looks
-    looks = config.getLooks()
-    if looks:
-        colorspace_data["looks"] = {
-            look.getName(): {"process_space": look.getProcessSpace()}
-            for look in looks
-        }
-
-    # add roles
-    roles = config.getRoles()
-    if roles:
-        colorspace_data["roles"] = {
-            role: {"colorspace": colorspace}
-            for (role, colorspace) in roles
-        }
-
-    return colorspace_data
-
-
-@config.command(
-    name="get_views",
-    help=(
-        "return all viewers from config file "
-        "--path input arg is required"
+    _save_output_to_json_file(
+        get_ocio_config_colorspaces(config_path),
+        output_path
     )
-)
-@click.option("--in_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_views(in_path, out_path):
+
+
+@main.command(
+    name="get_ocio_config_views",
+    help="All viewers from config file")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_ocio_config_views(config_path, output_path):
     """Aggregate all viewers to file.
 
-    Python 2 wrapped console command
-
     Args:
-        in_path (str): config file path string
-        out_path (str): temp json file path string
+        config_path (str): config file path string
+        output_path (str): temp json file path string
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config get_views \
-        --in_path=<path> --out_path=<path>
+        --config_path <path> --output <path>
     """
-    json_path = Path(out_path)
-
-    out_data = _get_views_data(in_path)
-
-    with open(json_path, "w") as f_:
-        json.dump(out_data, f_)
-
-    print(f"Viewer data are saved to '{json_path}'")
-
-
-def _get_views_data(config_path):
-    """Return all found viewer data.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: aggregated available viewers
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError("Input path should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    data_ = {}
-    for display in config.getDisplays():
-        for view in config.getViews(display):
-            colorspace = config.getDisplayViewColorSpaceName(display, view)
-            # Special token. See https://opencolorio.readthedocs.io/en/latest/guides/authoring/authoring.html#shared-views # noqa
-            if colorspace == "<USE_DISPLAY_NAME>":
-                colorspace = display
-
-            data_[f"{display}/{view}"] = {
-                "display": display,
-                "view": view,
-                "colorspace": colorspace
-            }
-
-    return data_
-
-
-@config.command(
-    name="get_version",
-    help=(
-        "return major and minor version from config file "
-        "--config_path input arg is required"
-        "--out_path input arg is required"
+    _save_output_to_json_file(
+        get_ocio_config_views(config_path),
+        output_path
     )
-)
-@click.option("--config_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_version(config_path, out_path):
-    """Get version of config.
 
-    Python 2 wrapped console command
+
+@main.command(
+    name="get_config_version_data",
+    help="Get major and minor version from config file")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_config_version_data(config_path, output_path):
+    """Get version of config.
 
     Args:
         config_path (str): ocio config file path string
-        out_path (str): temp json file path string
+        output_path (str): temp json file path string
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config get_version \
-        --config_path=<path> --out_path=<path>
+        --config_path <path> --output_path <path>
     """
-    json_path = Path(out_path)
-
-    out_data = _get_version_data(config_path)
-
-    with open(json_path, "w") as f_:
-        json.dump(out_data, f_)
-
-    print(f"Config version data are saved to '{json_path}'")
-
-
-def _get_version_data(config_path):
-    """Return major and minor version info.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: minor and major keys with values
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError("Input path should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    return {
-        "major": config.getMajorVersion(),
-        "minor": config.getMinorVersion()
-    }
-
-
-@colorspace.command(
-    name="get_config_file_rules_colorspace_from_filepath",
-    help=(
-        "return colorspace from filepath "
-        "--config_path - ocio config file path (input arg is required) "
-        "--filepath - any file path (input arg is required) "
-        "--out_path - temp json file path (input arg is required)"
+    _save_output_to_json_file(
+        get_config_version_data(config_path),
+        output_path
     )
-)
-@click.option("--config_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--filepath", required=True,
-              help="path to file to get colorspace from",
-              type=click.Path())
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-def get_config_file_rules_colorspace_from_filepath(
-    config_path, filepath, out_path
+
+
+@main.command(
+    name="get_config_file_rules_colorspace_from_filepath",
+    help="Colorspace file rules from filepath")
+@click.option(
+    "--config_path",
+    required=True,
+    help="OCIO config path to read ocio config file.",
+    type=click.Path(exists=True))
+@click.option(
+    "--filepath",
+    required=True,
+    help="Path to file to get colorspace from.",
+    type=click.Path())
+@click.option(
+    "--output_path",
+    required=True,
+    help="Path where to write output json file.",
+    type=click.Path())
+def _get_config_file_rules_colorspace_from_filepath(
+    config_path, filepath, output_path
 ):
     """Get colorspace from file path wrapper.
 
-    Python 2 wrapped console command
-
     Args:
         config_path (str): config file path string
         filepath (str): path string leading to file
-        out_path (str): temp json file path string
+        output_path (str): temp json file path string
 
     Example of use:
-    > pyton.exe ./ocio_wrapper.py \
+    > python.exe ./ocio_wrapper.py \
         colorspace get_config_file_rules_colorspace_from_filepath \
-        --config_path=<path> --filepath=<path> --out_path=<path>
+        --config_path <path> --filepath <path> --output_path <path>
     """
-    json_path = Path(out_path)
-
-    colorspace = _get_config_file_rules_colorspace_from_filepath(
-        config_path, filepath)
-
-    with open(json_path, "w") as f_:
-        json.dump(colorspace, f_)
-
-    print(f"Colorspace name is saved to '{json_path}'")
+    _save_output_to_json_file(
+        get_config_file_rules_colorspace_from_filepath(config_path, filepath),
+        output_path
+    )
 
 
-def _get_config_file_rules_colorspace_from_filepath(config_path, filepath):
-    """Return found colorspace data found in v2 file rules.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-        filepath (str): path string leading to v2 file rules
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        dict: aggregated available colorspaces
-    """
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError(
-            f"Input path `{config_path}` should be `config.ocio` file")
-
-    config = ocio.Config().CreateFromFile(str(config_path))
-
-    # TODO: use `parseColorSpaceFromString` instead if ocio v1
-    colorspace = config.getColorSpaceFromFilepath(str(filepath))
-
-    return colorspace
-
-
-def _get_display_view_colorspace_name(config_path, display, view):
-    """Returns the colorspace attribute of the (display, view) pair.
-
-    Args:
-        config_path (str): path string leading to config.ocio
-        display (str): display name e.g. "ACES"
-        view (str): view name e.g. "sRGB"
-
-
-    Raises:
-        IOError: Input config does not exist.
-
-    Returns:
-        view color space name (str) e.g. "Output - sRGB"
-    """
-
-    config_path = Path(config_path)
-
-    if not config_path.is_file():
-        raise IOError("Input path should be `config.ocio` file")
-
-    config = ocio.Config.CreateFromFile(str(config_path))
-    colorspace = config.getDisplayViewColorSpaceName(display, view)
-
-    return colorspace
-
-
-@config.command(
+@main.command(
     name="get_display_view_colorspace_name",
     help=(
-        "return default view colorspace name "
-        "for the given display and view "
-        "--path input arg is required"
-    )
-)
-@click.option("--in_path", required=True,
-              help="path where to read ocio config file",
-              type=click.Path(exists=True))
-@click.option("--out_path", required=True,
-              help="path where to write output json file",
-              type=click.Path())
-@click.option("--display", required=True,
-              help="display name",
-              type=click.STRING)
-@click.option("--view", required=True,
-              help="view name",
-              type=click.STRING)
-def get_display_view_colorspace_name(in_path, out_path,
-                                     display, view):
+        "Default view colorspace name for the given display and view"
+    ))
+@click.option(
+    "--config_path",
+    required=True,
+    help="path where to read ocio config file",
+    type=click.Path(exists=True))
+@click.option(
+    "--display",
+    required=True,
+    help="Display name",
+    type=click.STRING)
+@click.option(
+    "--view",
+    required=True,
+    help="view name",
+    type=click.STRING)
+@click.option(
+    "--output_path",
+    required=True,
+    help="path where to write output json file",
+    type=click.Path())
+def _get_display_view_colorspace_name(
+    config_path, display, view, output_path
+):
     """Aggregate view colorspace name to file.
 
     Wrapper command for processes without access to OpenColorIO
 
     Args:
-        in_path (str): config file path string
-        out_path (str): temp json file path string
+        config_path (str): config file path string
+        output_path (str): temp json file path string
         display (str): display name e.g. "ACES"
         view (str): view name e.g. "sRGB"
 
     Example of use:
     > pyton.exe ./ocio_wrapper.py config \
-        get_display_view_colorspace_name --in_path=<path> \
-        --out_path=<path> --display=<display> --view=<view>
+        get_display_view_colorspace_name --config_path <path> \
+        --output_path <path> --display <display> --view <view>
     """
+    _save_output_to_json_file(
+        get_display_view_colorspace_name(config_path, display, view),
+        output_path
+    )
 
-    out_data = _get_display_view_colorspace_name(in_path,
-                                                 display,
-                                                 view)
 
-    with open(out_path, "w") as f:
-        json.dump(out_data, f)
-
-    print(f"Display view colorspace saved to '{out_path}'")
-
-if __name__ == '__main__':
+if __name__ == "__main__":
+    if not has_compatible_ocio_package():
+        raise RuntimeError("OpenColorIO is not available.")
     main()
diff --git a/client/ayon_core/tools/loader/ui/window.py b/client/ayon_core/tools/loader/ui/window.py
index 3a6f4679fa..8529a53b06 100644
--- a/client/ayon_core/tools/loader/ui/window.py
+++ b/client/ayon_core/tools/loader/ui/window.py
@@ -335,9 +335,7 @@ class LoaderWindow(QtWidgets.QWidget):
 
     def closeEvent(self, event):
         super(LoaderWindow, self).closeEvent(event)
-        # Deselect project so current context will be selected
-        #   on next 'showEvent'
-        self._controller.set_selected_project(None)
+
         self._reset_on_show = True
 
     def keyPressEvent(self, event):
diff --git a/server_addon/nuke/package.py b/server_addon/nuke/package.py
index bf03c4e7e7..e522b9fb5d 100644
--- a/server_addon/nuke/package.py
+++ b/server_addon/nuke/package.py
@@ -1,3 +1,3 @@
 name = "nuke"
 title = "Nuke"
-version = "0.1.11"
+version = "0.1.12"
diff --git a/server_addon/nuke/server/settings/publish_plugins.py b/server_addon/nuke/server/settings/publish_plugins.py
index d5b05d8715..e67f7be24f 100644
--- a/server_addon/nuke/server/settings/publish_plugins.py
+++ b/server_addon/nuke/server/settings/publish_plugins.py
@@ -125,6 +125,7 @@ class ReformatNodesConfigModel(BaseSettingsModel):
 
 class IntermediateOutputModel(BaseSettingsModel):
     name: str = SettingsField(title="Output name")
+    publish: bool = SettingsField(title="Publish")
     filter: BakingStreamFilterModel = SettingsField(
         title="Filter", default_factory=BakingStreamFilterModel)
     read_raw: bool = SettingsField(
@@ -346,6 +347,7 @@ DEFAULT_PUBLISH_PLUGIN_SETTINGS = {
         "outputs": [
             {
                 "name": "baking",
+                "publish": False,
                 "filter": {
                     "task_types": [],
                     "product_types": [],
@@ -401,6 +403,7 @@ DEFAULT_PUBLISH_PLUGIN_SETTINGS = {
         "outputs": [
             {
                 "name": "baking",
+                "publish": False,
                 "filter": {
                     "task_types": [],
                     "product_types": [],