Merge branch 'develop' into feature/OP-5548_Fusion-Deadline-and-publish

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -35,6 +35,7 @@ body:
       label: Version
       description: What version are you running? Look to OpenPype Tray
       options:
+        - 3.15.7-nightly.3
         - 3.15.7-nightly.2
         - 3.15.7-nightly.1
         - 3.15.6
@@ -134,7 +135,6 @@ body:
         - 3.14.1-nightly.4
         - 3.14.1-nightly.3
         - 3.14.1-nightly.2
-        - 3.14.1-nightly.1
     validations:
       required: true
   - type: dropdown

.gitignore

@@ -112,3 +112,9 @@ tools/run_eventserver.*
 tools/dev_*
 
 .github_changelog_generator
+
+
+# Addons
+########
+/openpype/addons/*
+!/openpype/addons/README.md

openpype/addons/README.md

@@ -0,0 +1,3 @@
+This directory is for storing external addons that needs to be included in the pipeline when distributed.
+
+The directory is ignored by Git, but included in the zip and installation files.

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

@@ -96,7 +96,7 @@ class CreateSaver(NewCreator):
         for tool in tools:
             data = self.get_managed_tool_data(tool)
             if not data:
-                data = self._collect_saver(tool)
+                continue
 
             # Add instance
             created_instance = CreatedInstance.from_existing(data, self)
@@ -173,26 +173,6 @@ class CreateSaver(NewCreator):
             print(f"Renaming {tool.Name} -> {subset}")
             tool.SetAttrs({"TOOLS_Name": subset})
 
-    def _collect_saver(self, tool):
-        attrs = tool.GetAttrs()
-
-        keys = ["id", "asset", "subset", "task", "variant"]
-        ctx_data = {key: tool.GetData(f"openpype.{key}") for key in keys}
-        passthrough = attrs["TOOLB_PassThrough"]
-        return {
-            # Required data
-            "project": self.project_name,
-            "asset": ctx_data["asset"],
-            "subset": ctx_data["subset"],
-            "task": ctx_data["task"],
-            "variant": ctx_data["variant"],
-            "active": not passthrough,
-            "family": self.family,
-            # Unique identifier for instance and this creator
-            "id": ctx_data["id"],
-            "creator_identifier": self.identifier,
-        }
-
     def get_managed_tool_data(self, tool):
         """Return data of the tool if it matches creator identifier"""
         data = tool.GetData("openpype")

openpype/hosts/max/api/lib.py

@@ -138,7 +138,7 @@ def get_default_render_folder(project_setting=None):
                            ["default_render_image_folder"])
 
 
-def set_framerange(start_frame, end_frame):
+def set_render_frame_range(start_frame, end_frame):
     """
     Note:
         Frame range can be specified in different types. Possible values are:
@@ -150,10 +150,10 @@ def set_framerange(start_frame, end_frame):
     Todo:
         Current type is hard-coded, there should be a custom setting for this.
     """
-    rt.rendTimeType = 4
+    rt.rendTimeType = 3
     if start_frame is not None and end_frame is not None:
-        frame_range = "{0}-{1}".format(start_frame, end_frame)
-        rt.rendPickupFrames = frame_range
+        rt.rendStart = int(start_frame)
+        rt.rendEnd = int(end_frame)
 
 
 def get_multipass_setting(project_setting=None):
@@ -173,10 +173,16 @@ def set_scene_resolution(width: int, height: int):
         None
 
     """
+    # make sure the render dialog is closed
+    # for the update of resolution
+    # Changing the Render Setup dialog settingsshould be done
+    # with the actual Render Setup dialog in a closed state.
+    if rt.renderSceneDialog.isOpen():
+        rt.renderSceneDialog.close()
+
     rt.renderWidth = width
     rt.renderHeight = height
 
-
 def reset_scene_resolution():
     """Apply the scene resolution from the project definition
 
@@ -243,6 +249,7 @@ def reset_frame_range(fps: bool = True):
     frame_end = frame_range["frameEnd"] + int(frame_range["handleEnd"])
     frange_cmd = f"animationRange = interval {frame_start} {frame_end}"
     rt.execute(frange_cmd)
+    set_render_frame_range(frame_start, frame_end)
 
 
 def set_context_setting():
@@ -259,6 +266,7 @@ def set_context_setting():
         None
     """
     reset_scene_resolution()
+    reset_frame_range()
 
 
 def get_max_version():

openpype/hosts/max/api/lib_renderproducts.py

@@ -36,8 +36,9 @@ class RenderProducts(object):
                                    container)
 
         context = get_current_project_asset()
-        startFrame = context["data"].get("frameStart")
-        endFrame = context["data"].get("frameEnd") + 1
+        # TODO: change the frame range follows the current render setting
+        startFrame = int(rt.rendStart)
+        endFrame = int(rt.rendEnd) + 1
 
         img_fmt = self._project_settings["max"]["RenderSettings"]["image_format"]   # noqa
         full_render_list = self.beauty_render_product(output_file,

openpype/hosts/max/api/lib_rendersettings.py

@@ -6,7 +6,7 @@ from openpype.pipeline import legacy_io
 from openpype.pipeline.context_tools import get_current_project_asset
 
 from openpype.hosts.max.api.lib import (
-    set_framerange,
+    set_render_frame_range,
     get_current_renderer,
     get_default_render_folder
 )
@@ -68,7 +68,7 @@ class RenderSettings(object):
         # Set Frame Range
         frame_start = context["data"].get("frame_start")
         frame_end = context["data"].get("frame_end")
-        set_framerange(frame_start, frame_end)
+        set_render_frame_range(frame_start, frame_end)
         # get the production render
         renderer_class = get_current_renderer()
         renderer = str(renderer_class).split(":")[0]
@@ -105,6 +105,9 @@ class RenderSettings(object):
 
         rt.rendSaveFile = True
 
+        if rt.renderSceneDialog.isOpen():
+            rt.renderSceneDialog.close()
+
     def arnold_setup(self):
         # get Arnold RenderView run in the background
         # for setting up renderable camera

openpype/hosts/max/api/pipeline.py

@@ -52,6 +52,7 @@ class MaxHost(HostBase, IWorkfileHost, ILoadHost, INewPublisher):
 
         def context_setting():
             return lib.set_context_setting()
+
         rt.callbacks.addScript(rt.Name('systemPostNew'),
                                context_setting)
 

openpype/hosts/max/plugins/create/create_render.py

@@ -27,6 +27,11 @@ class CreateRender(plugin.MaxCreator):
         # for additional work on the node:
         # instance_node = rt.getNodeByName(instance.get("instance_node"))
 
+        # make sure the render dialog is closed
+        # for the update of resolution
+        # Changing the Render Setup dialog settings should be done
+        # with the actual Render Setup dialog in a closed state.
+
         # set viewport camera for rendering(mandatory for deadline)
         RenderSettings().set_render_camera(sel_obj)
         # set output paths for rendering(mandatory for deadline)

openpype/hosts/max/plugins/publish/collect_render.py

@@ -46,7 +46,6 @@ class CollectRender(pyblish.api.InstancePlugin):
 
         self.log.debug(f"Setting {version_int} to context.")
         context.data["version"] = version_int
-
         # setup the plugin as 3dsmax for the internal renderer
         data = {
             "subset": instance.name,
@@ -59,8 +58,8 @@ class CollectRender(pyblish.api.InstancePlugin):
             "source": filepath,
             "expectedFiles": render_layer_files,
             "plugin": "3dsmax",
-            "frameStart": context.data['frameStart'],
-            "frameEnd": context.data['frameEnd'],
+            "frameStart": int(rt.rendStart),
+            "frameEnd": int(rt.rendEnd),
             "version": version_int,
             "farm": True
         }

openpype/hosts/max/plugins/publish/validate_frame_range.py

@@ -0,0 +1,64 @@
+import pyblish.api
+
+from pymxs import runtime as rt
+from openpype.pipeline import (
+    OptionalPyblishPluginMixin
+)
+from openpype.pipeline.publish import (
+    RepairAction,
+    ValidateContentsOrder,
+    PublishValidationError
+)
+
+
+class ValidateFrameRange(pyblish.api.InstancePlugin,
+                         OptionalPyblishPluginMixin):
+    """Validates the frame ranges.
+
+    This is an optional validator checking if the frame range on instance
+    matches the frame range specified for the asset.
+
+    It also validates render frame ranges of render layers.
+
+    Repair action will change everything to match the asset frame range.
+
+    This can be turned off by the artist to allow custom ranges.
+    """
+
+    label = "Validate Frame Range"
+    order = ValidateContentsOrder
+    families = ["maxrender"]
+    hosts = ["max"]
+    optional = True
+    actions = [RepairAction]
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            self.log.info("Skipping validation...")
+            return
+        context = instance.context
+
+        frame_start = int(context.data.get("frameStart"))
+        frame_end = int(context.data.get("frameEnd"))
+
+        inst_frame_start = int(instance.data.get("frameStart"))
+        inst_frame_end = int(instance.data.get("frameEnd"))
+
+        errors = []
+        if frame_start != inst_frame_start:
+            errors.append(
+                f"Start frame ({inst_frame_start}) on instance does not match " # noqa
+                f"with the start frame ({frame_start}) set on the asset data. ")    # noqa
+        if frame_end != inst_frame_end:
+            errors.append(
+                f"End frame ({inst_frame_end}) on instance does not match "
+                f"with the end frame ({frame_start}) from the asset data. ")
+
+        if errors:
+            errors.append("You can use repair action to fix it.")
+            raise PublishValidationError("\n".join(errors))
+
+    @classmethod
+    def repair(cls, instance):
+        rt.rendStart = instance.context.data.get("frameStart")
+        rt.rendEnd = instance.context.data.get("frameEnd")

openpype/hosts/max/plugins/publish/validate_resolution_setting.py

@@ -0,0 +1,65 @@
+import pyblish.api
+from openpype.pipeline import (
+    PublishValidationError,
+    OptionalPyblishPluginMixin
+)
+from pymxs import runtime as rt
+from openpype.hosts.max.api.lib import reset_scene_resolution
+
+from openpype.pipeline.context_tools import (
+    get_current_project_asset,
+    get_current_project
+)
+
+
+class ValidateResolutionSetting(pyblish.api.InstancePlugin,
+                                OptionalPyblishPluginMixin):
+    """Validate the resolution setting aligned with DB"""
+
+    order = pyblish.api.ValidatorOrder - 0.01
+    families = ["maxrender"]
+    hosts = ["max"]
+    label = "Validate Resolution Setting"
+    optional = True
+
+    def process(self, instance):
+        if not self.is_active(instance.data):
+            return
+        width, height = self.get_db_resolution(instance)
+        current_width = rt.renderwidth
+        current_height = rt.renderHeight
+        if current_width != width and current_height != height:
+            raise PublishValidationError("Resolution Setting "
+                                         "not matching resolution "
+                                         "set on asset or shot.")
+        if current_width != width:
+            raise PublishValidationError("Width in Resolution Setting "
+                                         "not matching resolution set "
+                                         "on asset or shot.")
+
+        if current_height != height:
+            raise PublishValidationError("Height in Resolution Setting "
+                                         "not matching resolution set "
+                                         "on asset or shot.")
+
+    def get_db_resolution(self, instance):
+        data = ["data.resolutionWidth", "data.resolutionHeight"]
+        project_resolution = get_current_project(fields=data)
+        project_resolution_data = project_resolution["data"]
+        asset_resolution = get_current_project_asset(fields=data)
+        asset_resolution_data = asset_resolution["data"]
+        # Set project resolution
+        project_width = int(
+            project_resolution_data.get("resolutionWidth", 1920))
+        project_height = int(
+            project_resolution_data.get("resolutionHeight", 1080))
+        width = int(
+            asset_resolution_data.get("resolutionWidth", project_width))
+        height = int(
+            asset_resolution_data.get("resolutionHeight", project_height))
+
+        return width, height
+
+    @classmethod
+    def repair(cls, instance):
+        reset_scene_resolution()

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

@@ -50,7 +50,8 @@ class ValidateShaderName(pyblish.api.InstancePlugin):
         asset_name = instance.data.get("asset", None)
 
         # Check the number of connected shadingEngines per shape
-        r = re.compile(cls.regex)
+        regex_compile = re.compile(cls.regex)
+        error_message = "object {0} has invalid shader name {1}"
         for shape in shapes:
             shading_engines = cmds.listConnections(shape,
                                                    destination=True,
@@ -60,19 +61,18 @@ class ValidateShaderName(pyblish.api.InstancePlugin):
             )
 
             for shader in shaders:
-                m = r.match(cls.regex, shader)
+                m = regex_compile.match(shader)
                 if m is None:
                     invalid.append(shape)
-                    cls.log.error(
-                        "object {0} has invalid shader name {1}".format(shape,
-                                                                        shader)
-                    )
+                    cls.log.error(error_message.format(shape, shader))
                 else:
-                    if 'asset' in r.groupindex:
+                    if 'asset' in regex_compile.groupindex:
                         if m.group('asset') != asset_name:
                             invalid.append(shape)
-                            cls.log.error(("object {0} has invalid "
-                                           "shader name {1}").format(shape,
-                                                                     shader))
+                            message = error_message
+                            message += " with missing asset name \"{2}\""
+                            cls.log.error(
+                                message.format(shape, shader, asset_name)
+                            )
 
         return invalid

openpype/modules/base.py

@@ -311,6 +311,7 @@ def _load_modules():
     # Look for OpenPype modules in paths defined with `get_module_dirs`
     #   - dynamically imported OpenPype modules and addons
     module_dirs = get_module_dirs()
+
     # Add current directory at first place
     #   - has small differences in import logic
     current_dir = os.path.abspath(os.path.dirname(__file__))
@@ -318,8 +319,11 @@ def _load_modules():
     module_dirs.insert(0, hosts_dir)
     module_dirs.insert(0, current_dir)
 
+    addons_dir = os.path.join(os.path.dirname(current_dir), "addons")
+    module_dirs.append(addons_dir)
+
     processed_paths = set()
-    for dirpath in module_dirs:
+    for dirpath in frozenset(module_dirs):
         # Skip already processed paths
         if dirpath in processed_paths:
             continue

openpype/modules/ftrack/plugins/publish/integrate_hierarchy_ftrack.py

@@ -378,7 +378,7 @@ class IntegrateHierarchyToFtrack(pyblish.api.ContextPlugin):
                     existing_tasks.append(task_name_low)
 
                     for instance in instances_by_task_name[task_name_low]:
-                        instance["ftrackTask"] = child
+                        instance.data["ftrackTask"] = child
 
             for task_name in tasks:
                 task_type = tasks[task_name]["type"]

openpype/modules/kitsu/plugins/publish/integrate_kitsu_note.py

@@ -9,7 +9,7 @@ class IntegrateKitsuNote(pyblish.api.ContextPlugin):
 
     order = pyblish.api.IntegratorOrder
     label = "Kitsu Note and Status"
-    families = ["render", "kitsu"]
+    families = ["render", "image", "online", "plate", "kitsu"]
 
     # status settings
     set_status_note = False
@@ -52,8 +52,9 @@ class IntegrateKitsuNote(pyblish.api.ContextPlugin):
         for instance in context:
             # Check if instance is a review by checking its family
             # Allow a match to primary family or any of families
-            families = set([instance.data["family"]] +
-                           instance.data.get("families", []))
+            families = set(
+                [instance.data["family"]] + instance.data.get("families", [])
+            )
             if "review" not in families:
                 continue
 

openpype/modules/kitsu/plugins/publish/integrate_kitsu_review.py

@@ -8,11 +8,10 @@ class IntegrateKitsuReview(pyblish.api.InstancePlugin):
 
     order = pyblish.api.IntegratorOrder + 0.01
     label = "Kitsu Review"
-    families = ["render", "kitsu"]
+    families = ["render", "image", "online", "plate", "kitsu"]
     optional = True
 
     def process(self, instance):
-
         # Check comment has been created
         comment_id = instance.data.get("kitsu_comment", {}).get("id")
         if not comment_id:

openpype/pipeline/context_tools.py

@@ -35,6 +35,7 @@ from . import (
     register_inventory_action_path,
     register_creator_plugin_path,
     deregister_loader_plugin_path,
+    deregister_inventory_action_path,
 )
 
 
@@ -54,6 +55,7 @@ PLUGINS_DIR = os.path.join(PACKAGE_DIR, "plugins")
 # Global plugin paths
 PUBLISH_PATH = os.path.join(PLUGINS_DIR, "publish")
 LOAD_PATH = os.path.join(PLUGINS_DIR, "load")
+INVENTORY_PATH = os.path.join(PLUGINS_DIR, "inventory")
 
 
 def _get_modules_manager():
@@ -158,6 +160,7 @@ def install_openpype_plugins(project_name=None, host_name=None):
     pyblish.api.register_plugin_path(PUBLISH_PATH)
     pyblish.api.register_discovery_filter(filter_pyblish_plugins)
     register_loader_plugin_path(LOAD_PATH)
+    register_inventory_action_path(INVENTORY_PATH)
 
     if host_name is None:
         host_name = os.environ.get("AVALON_APP")
@@ -223,6 +226,7 @@ def uninstall_host():
     pyblish.api.deregister_plugin_path(PUBLISH_PATH)
     pyblish.api.deregister_discovery_filter(filter_pyblish_plugins)
     deregister_loader_plugin_path(LOAD_PATH)
+    deregister_inventory_action_path(INVENTORY_PATH)
     log.info("Global plug-ins unregistred")
 
     deregister_host()

openpype/pipeline/create/context.py

@@ -23,7 +23,7 @@ from openpype.lib.attribute_definitions import (
     get_default_values,
 )
 from openpype.host import IPublishHost, IWorkfileHost
-from openpype.pipeline import legacy_io
+from openpype.pipeline import legacy_io, Anatomy
 from openpype.pipeline.plugin_discover import DiscoverResult
 
 from .creator_plugins import (
@@ -1383,6 +1383,8 @@ class CreateContext:
         self._current_task_name = None
         self._current_workfile_path = None
 
+        self._current_project_anatomy = None
+
         self._host_is_valid = host_is_valid
         # Currently unused variable
         self.headless = headless
@@ -1546,6 +1548,18 @@ class CreateContext:
 
         return self._current_workfile_path
 
+    def get_current_project_anatomy(self):
+        """Project anatomy for current project.
+
+        Returns:
+            Anatomy: Anatomy object ready to be used.
+        """
+
+        if self._current_project_anatomy is None:
+            self._current_project_anatomy = Anatomy(
+                self._current_project_name)
+        return self._current_project_anatomy
+
     @property
     def context_has_changed(self):
         """Host context has changed.
@@ -1568,6 +1582,7 @@ class CreateContext:
         )
 
     project_name = property(get_current_project_name)
+    project_anatomy = property(get_current_project_anatomy)
 
     @property
     def log(self):
@@ -1680,6 +1695,8 @@ class CreateContext:
         self._current_task_name = task_name
         self._current_workfile_path = workfile_path
 
+        self._current_project_anatomy = None
+
     def reset_plugins(self, discover_publish_plugins=True):
         """Reload plugins.
 

openpype/pipeline/create/creator_plugins.py

@@ -231,10 +231,24 @@ class BaseCreator:
 
     @property
     def project_name(self):
-        """Family that plugin represents."""
+        """Current project name.
+
+        Returns:
+            str: Name of a project.
+        """
 
         return self.create_context.project_name
 
+    @property
+    def project_anatomy(self):
+        """Current project anatomy.
+
+        Returns:
+            Anatomy: Project anatomy object.
+        """
+
+        return self.create_context.project_anatomy
+
     @property
     def host(self):
         return self.create_context.host

openpype/plugins/inventory/remove_and_load.py

@@ -0,0 +1,51 @@
+from openpype.pipeline import InventoryAction
+from openpype.pipeline import get_current_project_name
+from openpype.pipeline.load.plugins import discover_loader_plugins
+from openpype.pipeline.load.utils import (
+    get_loader_identifier,
+    remove_container,
+    load_container,
+)
+from openpype.client import get_representation_by_id
+
+
+class RemoveAndLoad(InventoryAction):
+    """Delete inventory item and reload it."""
+
+    label = "Remove and load"
+    icon = "refresh"
+
+    def process(self, containers):
+        project_name = get_current_project_name()
+        loaders_by_name = {
+            get_loader_identifier(plugin): plugin
+            for plugin in discover_loader_plugins(project_name=project_name)
+        }
+        for container in containers:
+            # Get loader
+            loader_name = container["loader"]
+            loader = loaders_by_name.get(loader_name, None)
+            if not loader:
+                raise RuntimeError(
+                    "Failed to get loader '{}', can't remove "
+                    "and load container".format(loader_name)
+                )
+
+            # Get representation
+            representation = get_representation_by_id(
+                project_name, container["representation"]
+            )
+            if not representation:
+                self.log.warning(
+                    "Skipping remove and load because representation id is not"
+                    " found in database: '{}'".format(
+                        container["representation"]
+                    )
+                )
+                continue
+
+            # Remove container
+            remove_container(container)
+
+            # Load container
+            load_container(loader, representation)

openpype/plugins/publish/validate_sequence_frames.py

@@ -1,66 +0,0 @@
-import os
-import re
-
-import clique
-import pyblish.api
-
-
-class ValidateSequenceFrames(pyblish.api.InstancePlugin):
-    """Ensure the sequence of frames is complete
-
-    The files found in the folder are checked against the startFrame and
-    endFrame of the instance. If the first or last file is not
-    corresponding with the first or last frame it is flagged as invalid.
-
-    Used regular expression pattern handles numbers in the file names
-    (eg "Main_beauty.v001.1001.exr", "Main_beauty_v001.1001.exr",
-    "Main_beauty.1001.1001.exr") but not numbers behind frames (eg.
-    "Main_beauty.1001.v001.exr")
-    """
-
-    order = pyblish.api.ValidatorOrder
-    label = "Validate Sequence Frames"
-    families = ["imagesequence", "render"]
-    hosts = ["shell", "unreal"]
-
-    def process(self, instance):
-        representations = instance.data.get("representations")
-        if not representations:
-            return
-        for repr in representations:
-            repr_files = repr["files"]
-            if isinstance(repr_files, str):
-                continue
-
-            ext = repr.get("ext")
-            if not ext:
-                _, ext = os.path.splitext(repr_files[0])
-            elif not ext.startswith("."):
-                ext = ".{}".format(ext)
-            pattern = r"\D?(?P<index>(?P<padding>0*)\d+){}$".format(
-                re.escape(ext))
-            patterns = [pattern]
-
-            collections, remainder = clique.assemble(
-                repr_files, minimum_items=1, patterns=patterns)
-
-            assert not remainder, "Must not have remainder"
-            assert len(collections) == 1, "Must detect single collection"
-            collection = collections[0]
-            frames = list(collection.indexes)
-
-            if instance.data.get("slate"):
-                # Slate is not part of the frame range
-                frames = frames[1:]
-
-            current_range = (frames[0], frames[-1])
-
-            required_range = (instance.data["frameStart"],
-                              instance.data["frameEnd"])
-
-            if current_range != required_range:
-                raise ValueError(f"Invalid frame range: {current_range} - "
-                                 f"expected: {required_range}")
-
-            missing = collection.holes().indexes
-            assert not missing, "Missing frames: %s" % (missing,)

openpype/settings/defaults/project_settings/global.json

@@ -82,7 +82,8 @@
                         "png": {
                             "ext": "png",
                             "tags": [
-                                "ftrackreview"
+                                "ftrackreview",
+                                "kitsureview"
                             ],
                             "burnins": [],
                             "ffmpeg_args": {

openpype/settings/defaults/project_settings/max.json

@@ -19,5 +19,12 @@
             "custFloats": "custFloats",
             "custVecs": "custVecs"
         }
+    },
+    "publish": {
+        "ValidateFrameRange": {
+            "enabled": true,
+            "optional": true,
+            "active": true
+        }
     }
 }

openpype/settings/defaults/project_settings/maya.json

@@ -734,6 +734,7 @@
         "ValidateShaderName": {
             "enabled": false,
             "optional": true,
+            "active": true,
             "regex": "(?P<asset>.*)_(.*)_SHD"
         },
         "ValidateShadingEngine": {

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

@@ -73,6 +73,10 @@
                     }
                 }
             ]
+        },
+        {
+            "type": "schema",
+            "name": "schema_max_publish"
         }
     ]
 }

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

@@ -0,0 +1,33 @@
+{
+    "type": "dict",
+    "collapsible": true,
+    "key": "publish",
+    "label": "Publish plugins",
+    "children": [
+      {
+        "type": "dict",
+        "collapsible": true,
+        "checkbox_key": "enabled",
+        "key": "ValidateFrameRange",
+        "label": "Validate Frame Range",
+        "is_group": true,
+        "children": [
+            {
+                "type": "boolean",
+                "key": "enabled",
+                "label": "Enabled"
+            },
+            {
+                "type": "boolean",
+                "key": "optional",
+                "label": "Optional"
+            },
+            {
+                "type": "boolean",
+                "key": "active",
+                "label": "Active"
+            }
+        ]
+      }
+    ]
+  }

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

@@ -126,6 +126,11 @@
                     "key": "optional",
                     "label": "Optional"
                 },
+                {
+                    "type": "boolean",
+                    "key": "active",
+                    "label": "Active"
+                },
                 {
                     "type": "label",
                     "label": "Shader name regex can use named capture group <b>asset</b> to validate against current asset name.<p><b>Example:</b><br/><code>^.*(?P=&lt;asset&gt;.+)_SHD</code></p>"

openpype/version.py

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