init of entities system for settings

pype/settings/entities/_item_widgets.py

@@ -0,0 +1,115 @@
+class SettingWidget:
+    def __init__(self):
+        # TODO move to widget
+        if not self.available_for_role():
+            self.hide()
+            self.hidden_by_role = True
+
+    @classmethod
+    def style_state(
+        cls, has_studio_override, is_invalid, is_overriden, is_modified
+    ):
+        """Return stylesheet state by intered booleans."""
+        items = []
+        if is_invalid:
+            items.append("invalid")
+        else:
+            if is_overriden:
+                items.append("overriden")
+            if is_modified:
+                items.append("modified")
+
+        if not items and has_studio_override:
+            items.append("studio")
+
+        return "-".join(items) or ""
+
+    def show_actions_menu(self, event=None):
+        if event and event.button() != QtCore.Qt.RightButton:
+            return
+
+        if not self.allow_actions:
+            if event:
+                return self.mouseReleaseEvent(event)
+            return
+
+        menu = QtWidgets.QMenu()
+
+        actions_mapping = {}
+        if self.child_modified:
+            action = QtWidgets.QAction("Discard changes")
+            actions_mapping[action] = self._discard_changes
+            menu.addAction(action)
+
+        if (
+            self.is_overidable
+            and not self.is_overriden
+            and not self.any_parent_is_group
+        ):
+            action = QtWidgets.QAction("Set project override")
+            actions_mapping[action] = self._set_as_overriden
+            menu.addAction(action)
+
+        if (
+            not self.is_overidable
+            and (
+                self.has_studio_override or self.child_has_studio_override
+            )
+        ):
+            action = QtWidgets.QAction("Reset to pype default")
+            actions_mapping[action] = self._reset_to_pype_default
+            menu.addAction(action)
+
+        if (
+            not self.is_overidable
+            and not self.is_overriden
+            and not self.any_parent_is_group
+            and not self._had_studio_override
+        ):
+            action = QtWidgets.QAction("Set studio default")
+            actions_mapping[action] = self._set_studio_default
+            menu.addAction(action)
+
+        if (
+            not self.any_parent_overriden()
+            and (self.is_overriden or self.child_overriden)
+        ):
+            # TODO better label
+            action = QtWidgets.QAction("Remove project override")
+            actions_mapping[action] = self._remove_overrides
+            menu.addAction(action)
+
+        if not actions_mapping:
+            action = QtWidgets.QAction("< No action >")
+            actions_mapping[action] = None
+            menu.addAction(action)
+
+        result = menu.exec_(QtGui.QCursor.pos())
+        if result:
+            to_run = actions_mapping[result]
+            if to_run:
+                to_run()
+
+    def mouseReleaseEvent(self, event):
+        if self.allow_actions and event.button() == QtCore.Qt.RightButton:
+            return self.show_actions_menu()
+
+        mro = type(self).mro()
+        index = mro.index(self.__class__)
+        item = None
+        for idx in range(index + 1, len(mro)):
+            _item = mro[idx]
+            if hasattr(_item, "mouseReleaseEvent"):
+                item = _item
+                break
+
+        if item:
+            return item.mouseReleaseEvent(self, event)
+
+    def hierarchical_style_update(self):
+        """Trigger update style method down the hierarchy."""
+        raise NotImplementedError(
+            "{} Method `hierarchical_style_update` not implemented!".format(
+                repr(self)
+            )
+        )

pype/settings/entities/base_entity.py

@@ -0,0 +1,549 @@
+import enum
+import copy
+import inspect
+import logging
+from abc import ABCMeta, abstractmethod, abstractproperty
+
+import six
+
+from lib import NOT_SET, convert_data_to_gui_data
+from constants import WRAPPER_TYPES, SYSTEM_SETTINGS_KEY
+# from pype.settings.lib import get_default_settings
+import os
+import json
+
+
+def subkey_merge(_dict, value, keys):
+    key = keys.pop(0)
+    if not keys:
+        _dict[key] = value
+        return _dict
+
+    if key not in _dict:
+        _dict[key] = {}
+    _dict[key] = subkey_merge(_dict[key], value, keys)
+
+    return _dict
+
+
+def load_jsons_from_dir(path, *args, **kwargs):
+    output = {}
+
+    path = os.path.normpath(path)
+    if not os.path.exists(path):
+        # TODO warning
+        return output
+
+    sub_keys = list(kwargs.pop("subkeys", args))
+    for sub_key in tuple(sub_keys):
+        _path = os.path.join(path, sub_key)
+        if not os.path.exists(_path):
+            break
+
+        path = _path
+        sub_keys.pop(0)
+
+    base_len = len(path) + 1
+    for base, _directories, filenames in os.walk(path):
+        base_items_str = base[base_len:]
+        if not base_items_str:
+            base_items = []
+        else:
+            base_items = base_items_str.split(os.path.sep)
+
+        for filename in filenames:
+            basename, ext = os.path.splitext(filename)
+            if ext == ".json":
+                full_path = os.path.join(base, filename)
+                with open(full_path, "r") as opened_file:
+                    value = json.load(opened_file)
+
+                dict_keys = base_items + [basename]
+                output = subkey_merge(output, value, dict_keys)
+
+    for sub_key in sub_keys:
+        output = output[sub_key]
+    return output
+
+
+def get_default_settings():
+    defaults_dir = os.path.join(
+        os.path.dirname(os.path.dirname(__file__)),
+        "defaults"
+    )
+    return load_jsons_from_dir(defaults_dir)
+
+
+# from pype.api import Logger
+class Logger:
+    def get_logger(self, name):
+        return logging.getLogger(name)
+
+
+class InvalidValueType(Exception):
+    msg_template = "{}"
+
+    def __init__(self, valid_types, invalid_type, key):
+        msg = ""
+        if key:
+            msg += "Key \"{}\". ".format(key)
+
+        joined_types = ", ".join(
+            [str(valid_type) for valid_type in valid_types]
+        )
+        msg += "Got invalid type \"{}\". Expected: {}".format(
+            invalid_type, joined_types
+        )
+        self.msg = msg
+        super(InvalidValueType, self).__init__(msg)
+
+
+class OverrideState(enum.Enum):
+    STUDIO = 1
+    PROJECT = 1
+
+
+@six.add_metaclass(ABCMeta)
+class BaseEntity:
+    """Partially abstract class for Setting's item type workflow."""
+    # `is_input_type` attribute says if has implemented item type methods
+    is_input_type = True
+    # Each input must have implemented default value for development
+    # when defaults are not filled yet.
+    default_input_value = NOT_SET
+    # Will allow to show actions for the item type (disabled for proxies) else
+    # item is skipped and try to trigger actions on it's parent.
+    allow_actions = True
+    # If item can store environment values
+    allow_to_environment = False
+    # Item will expand to full width in grid layout
+    expand_in_grid = False
+
+    def __init__(self, schema_data, parent, is_dynamic_item=False):
+        self.schema_data = schema_data
+        self.parent = parent
+
+        # Log object
+        self._log = None
+
+        # These should be set on initialization and not change then
+        self.valid_value_types = NOT_SET
+
+        self.is_group = False
+        self.is_in_group = False
+
+        # NOTE was `as_widget`
+        self.is_dynamic_item = is_dynamic_item
+        self.is_in_dynamic_item = False
+
+        self.env_group_key = None
+        self.is_env_group = False
+
+        self.roles = None
+
+        # Item require key to be able load or store data
+        self.require_key = True
+
+        self.key = None
+        self.label = None
+
+        # These attributes may change values during existence of an object
+        # Values
+        self.default_value = NOT_SET
+        self.studio_override_value = NOT_SET
+        self.project_override_value = NOT_SET
+        self.current_value = NOT_SET
+
+        # Only for develop mode
+        self.defaults_not_set = False
+
+        # Default input attributes
+        self.has_studio_override = False
+        self.had_studio_override = False
+
+        self.has_project_override = False
+        self.had_project_override = False
+
+        self.value_is_modified = False
+        self.is_invalid = False
+
+        self.override_state = OverrideState.STUDIO
+
+    @abstractmethod
+    def set_override_state(self, state):
+        pass
+
+    def on_value_change(self):
+        # TODO implement
+        pass
+
+    @abstractmethod
+    def set_value(self, value):
+        pass
+
+    def validate_value(self, value):
+        if not self.valid_value_types:
+            return
+
+        for valid_type in self.valid_value_types:
+            if type(value) is valid_type:
+                return
+
+        key = getattr(self, "key", None)
+        raise InvalidValueType(self.valid_value_types, type(value), key)
+
+    def merge_metadata(self, current_metadata, new_metadata):
+        for key, value in new_metadata.items():
+            if key not in current_metadata:
+                current_metadata[key] = value
+
+            elif key == "groups":
+                current_metadata[key].extend(value)
+
+            elif key == "environments":
+                for group_key, subvalue in value.items():
+                    if group_key not in current_metadata[key]:
+                        current_metadata[key][group_key] = []
+                    current_metadata[key][group_key].extend(subvalue)
+
+            else:
+                raise KeyError("Unknown metadata key: \"{}\"".format(key))
+        return current_metadata
+
+    def available_for_role(self, role_name=None):
+        if not self.roles:
+            return True
+        if role_name is None:
+            role_name = self.user_role
+        return role_name in self.roles
+
+    @property
+    def user_role(self):
+        """Tool is running with any user role.
+
+        Returns:
+            str: user role as string.
+
+        """
+        return self.parent.user_role
+
+    @property
+    def is_overidable(self):
+        """ care about overrides."""
+        return self.parent.is_overidable
+
+    @property
+    def log(self):
+        """Auto created logger for debugging."""
+        if self._log is None:
+            self._log = Logger().get_logger(self.__class__.__name__)
+        return self._log
+
+    @abstractmethod
+    def update_default_values(self, parent_values):
+        """Fill default values on startup or on refresh.
+
+        Default values stored in `pype` repository should update all items in
+        schema. Each item should take values for his key and set it's value or
+        pass values down to children items.
+
+        Args:
+            parent_values (dict): Values of parent's item. But in case item is
+                used as widget, `parent_values` contain value for item.
+        """
+        pass
+
+    @abstractmethod
+    def update_studio_values(self, parent_values):
+        """Fill studio override values on startup or on refresh.
+
+        Set studio value if is not set to NOT_SET, in that case studio
+        overrides are not set yet.
+
+        Args:
+            parent_values (dict): Values of parent's item. But in case item is
+                used as widget, `parent_values` contain value for item.
+        """
+        pass
+
+    @abstractmethod
+    def update_project_values(self, parent_values):
+        """Fill project override values on startup, refresh or project change.
+
+        Set project value if is not set to NOT_SET, in that case project
+        overrides are not set yet.
+
+        Args:
+            parent_values (dict): Values of parent's item. But in case item is
+                used as widget, `parent_values` contain value for item.
+        """
+        pass
+
+    @abstractproperty
+    def schema_types(self):
+        pass
+
+    @abstractproperty
+    def child_has_studio_override(self):
+        """Any children item has studio overrides."""
+        pass
+
+    @abstractproperty
+    def child_value_modified(self):
+        """Any children item is modified."""
+        pass
+
+    @abstractproperty
+    def child_overriden(self):
+        """Any children item has project overrides."""
+        pass
+
+    @abstractproperty
+    def child_invalid(self):
+        """Any children item does not have valid value."""
+        pass
+
+    @abstractmethod
+    def get_invalid(self):
+        """Return invalid item types all down the hierarchy."""
+        pass
+
+    @abstractmethod
+    def settings_value(self):
+        """Value of an item without key."""
+        pass
+
+    @abstractmethod
+    def discard_changes(self):
+        """Item's implementation to discard all changes made by user.
+
+        Reset all values to same values as had when opened GUI
+        or when changed project.
+
+        Must not affect `had_studio_override` value or `was_overriden`
+        value. It must be marked that there are keys/values which are not in
+        defaults or overrides.
+        """
+        pass
+
+    @abstractmethod
+    def set_studio_default(self):
+        """Item's implementation to set current values as studio's overrides.
+
+        Mark item and it's children as they have studio overrides.
+        """
+        pass
+
+    @abstractmethod
+    def reset_to_pype_default(self):
+        """Item's implementation to remove studio overrides.
+
+        Mark item as it does not have studio overrides unset studio
+        override values.
+        """
+        pass
+
+    @abstractmethod
+    def remove_overrides(self):
+        """Item's implementation to remove project overrides.
+
+        Mark item as does not have project overrides. Must not change
+        `was_overriden` attribute value.
+        """
+        pass
+
+    @abstractmethod
+    def set_as_overriden(self):
+        """Item's implementation to set values as overriden for project.
+
+        Mark item and all it's children as they're overriden. Must skip
+        items with children items that has attributes `is_group`
+        and `any_parent_is_group` set to False. In that case those items
+        are not meant to be overridable and should trigger the method on it's
+        children.
+
+        """
+        pass
+
+
+class RootEntity(BaseEntity):
+    schema_types = ["root"]
+
+    def __init__(self, schema_data):
+        super(RootEntity, self).__init__(schema_data, None, None)
+        self.item_initalization()
+        self.reset_values()
+
+    def reset_values(self):
+        default_values = get_default_settings()[SYSTEM_SETTINGS_KEY]
+        for key, child_obj in self.non_gui_children.items():
+            child_obj.update_default_values(default_values[key])
+
+        studio_overrides = {}
+        for key, child_obj in self.non_gui_children.items():
+            value = studio_overrides.get(key, NOT_SET)
+            child_obj.update_studio_values(value)
+
+        # self.set_override_state(self.override_state)
+        # if self._hide_studio_overrides:
+        #     system_values = lib.NOT_SET
+        # else:
+        #     system_values = lib.convert_overrides_to_gui_data(
+        #         {self.main_schema_key: get_studio_system_settings_overrides()}
+        #     )
+        #
+        # for input_field in self.input_fields:
+        #     input_field.update_studio_values(system_values)
+
+    def __getitem__(self, key):
+        return self.non_gui_children[key]
+
+    def __setitem__(self, key, value):
+        self.non_gui_children[key].set_value(value)
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    def get(self, key, default=None):
+        return self.non_gui_children.get(key, default)
+
+    def keys(self):
+        return self.non_gui_children.keys()
+
+    def values(self):
+        return self.non_gui_children.values()
+
+    def items(self):
+        return self.non_gui_children.items()
+
+    def _add_children(self, schema_data, first=True):
+        added_children = []
+        for children_schema in schema_data["children"]:
+            if children_schema["type"] in WRAPPER_TYPES:
+                _children_schema = copy.deepcopy(children_schema)
+                wrapper_children = self._add_children(
+                    children_schema["children"]
+                )
+                _children_schema["children"] = wrapper_children
+                added_children.append(_children_schema)
+                continue
+
+            child_obj = self.create_schema_object(children_schema, self)
+            self.children.append(child_obj)
+            added_children.append(child_obj)
+            if type(child_obj) in self._gui_types:
+                continue
+
+            if child_obj.key in self.non_gui_children:
+                raise KeyError("Duplicated key \"{}\"".format(child_obj.key))
+            self.non_gui_children[child_obj.key] = child_obj
+
+        if not first:
+            return added_children
+
+        for child_obj in added_children:
+            if isinstance(child_obj, BaseEntity):
+                continue
+            self.gui_wrappers.append(child_obj)
+
+    def item_initalization(self):
+        self._loaded_types = None
+        self._gui_types = None
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (dict, )
+        self.children = []
+        self.non_gui_children = {}
+        self.gui_wrappers = []
+        self._add_children(self.schema_data)
+
+    def create_schema_object(self, schema_data, *args, **kwargs):
+        if self._loaded_types is None:
+            import item_entities
+            self._loaded_types = {}
+            self._gui_types = []
+            for attr in dir(item_entities):
+                item = getattr(item_entities, attr)
+                if not inspect.isclass(item):
+                    continue
+
+                if (
+                    not issubclass(item, BaseEntity)
+                    or inspect.isabstract(item)
+                ):
+                    # if item is BaseEntity:
+                    #     continue
+                    # item()
+                    continue
+
+                for schema_type in item.schema_types:
+                    self._loaded_types[schema_type] = item
+
+                gui_type = getattr(item, "gui_type", False)
+                if gui_type:
+                    self._gui_types.append(item)
+
+        klass = self._loaded_types.get(schema_data["type"])
+        if not klass:
+            raise KeyError("Unknown type \"{}\"".format(schema_data["type"]))
+        return klass(schema_data, *args, **kwargs)
+
+    def set_override_state(self, state):
+        self.override_state = state
+        for child_obj in self.non_gui_children.values():
+            child_obj.set_override_state(state)
+
+    def set_value(self, value):
+        raise KeyError("{} does not allow to use `set_value`.".format(
+            self.__class__.__name__
+        ))
+
+    @property
+    def child_has_studio_override(self):
+        pass
+
+    @property
+    def child_invalid(self):
+        for child_obj in self.non_gui_children.values():
+            if child_obj.child_invalid:
+                return True
+        return False
+
+    @property
+    def child_value_modified(self):
+        pass
+
+    @property
+    def child_overriden(self):
+        pass
+
+    def discard_changes(self):
+        pass
+
+    def get_invalid(self):
+        pass
+
+    def settings_value(self):
+        pass
+
+    def remove_overrides(self):
+        pass
+
+    def reset_to_pype_default(self):
+        pass
+
+    def set_as_overriden(self):
+        pass
+
+    def set_studio_default(self):
+        pass
+
+    def update_default_values(self, parent_values):
+        pass
+
+    def update_studio_values(self, parent_values):
+        pass
+
+    def update_project_values(self, parent_values):
+        pass

pype/settings/entities/constants.py

@@ -0,0 +1,35 @@
+# Metadata keys for work with studio and project overrides
+M_OVERRIDEN_KEY = "__overriden_keys__"
+# Metadata key for storing information about environments
+M_ENVIRONMENT_KEY = "__environment_keys__"
+# Metadata key for storing dynamic created labels
+M_DYNAMIC_KEY_LABEL = "__dynamic_keys_labels__"
+# NOTE key popping not implemented yet
+M_POP_KEY = "__pop_key__"
+
+METADATA_KEYS = (
+    M_OVERRIDEN_KEY,
+    M_ENVIRONMENT_KEY,
+    M_DYNAMIC_KEY_LABEL,
+    M_POP_KEY
+)
+
+# File where studio's system overrides are stored
+SYSTEM_SETTINGS_KEY = "system_settings"
+PROJECT_SETTINGS_KEY = "project_settings"
+PROJECT_ANATOMY_KEY = "project_anatomy"
+
+WRAPPER_TYPES = ["form", "collapsible-wrap"]
+
+__all__ = (
+    "M_OVERRIDEN_KEY",
+    "M_ENVIRONMENT_KEY",
+    "M_DYNAMIC_KEY_LABEL",
+    "M_POP_KEY",
+
+    "METADATA_KEYS",
+
+    "SYSTEM_SETTINGS_KEY",
+    "PROJECT_SETTINGS_KEY",
+    "PROJECT_ANATOMY_KEY"
+)

pype/settings/entities/item_entities.py

@@ -0,0 +1,711 @@
+import copy
+from abc import abstractmethod
+
+from lib import NOT_SET
+from constants import WRAPPER_TYPES
+from base_entity import BaseEntity, RootEntity, OverrideState
+
+
+"""
+# Abstract properties:
+schema_types
+child_has_studio_override
+child_value_modified
+child_overriden
+child_invalid
+
+# Abstract methods:
+
+"""
+
+class ItemEntity(BaseEntity):
+    def __init__(self, schema_data, parent, is_dynamic_item=False):
+        super(ItemEntity, self).__init__(schema_data, parent, is_dynamic_item)
+
+        self.create_schema_object = self.parent.create_schema_object
+
+        self.is_group = schema_data.get("is_group", False)
+        self.is_in_group = bool(
+            not self.is_group
+            and (parent.is_group or parent.is_in_group)
+        )
+
+        self.is_in_dynamic_item = bool(
+            not is_dynamic_item
+            and (parent.is_dynamic_item or parent.is_in_dynamic_item)
+        )
+
+        # If value should be stored to environments
+        self.env_group_key = schema_data.get("env_group_key")
+        self.is_env_group = bool(self.env_group_key is not None)
+
+        roles = schema_data.get("roles")
+        if roles is None:
+            roles = parent.roles
+        elif not isinstance(roles, list):
+            roles = [roles]
+        self.roles = roles
+
+        # States of inputs
+        # QUESTION has usage in entity?
+        self.state = None
+
+        self.key = schema_data.get("key")
+        self.label = schema_data.get("label")
+
+        self.item_initalization()
+
+        if self.valid_value_types is NOT_SET:
+            raise ValueError("Attribute `valid_value_types` is not filled.")
+
+        if self.require_key and not self.key:
+            error_msg = "Missing \"key\" in schema data. {}".format(
+                str(schema_data).replace("'", '"')
+            )
+            raise KeyError(error_msg)
+
+        if not self.label and self.is_group:
+            raise ValueError(
+                "Item is set as `is_group` but has empty `label`."
+            )
+
+    @abstractmethod
+    def item_initalization(self):
+        pass
+
+    def set_override_state(self, state):
+        if state == self.override_state:
+            return
+
+        self.override_state = state
+        if state is OverrideState.STUDIO:
+            self.set_value(self.studio_override_value)
+        elif state is OverrideState.PROJECT:
+            self.set_value(self.project_override_value)
+
+
+class DictImmutableKeysEntity(ItemEntity):
+    schema_types = ["dict"]
+
+    def __getitem__(self, key):
+        return self.non_gui_children[key]
+
+    def __setitem__(self, key, value):
+        child_obj = self.non_gui_children[key]
+        child_obj.set_value(value)
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    def get(self, key, default=None):
+        return self.non_gui_children.get(key, default)
+
+    def keys(self):
+        return self.non_gui_children.keys()
+
+    def values(self):
+        return self.non_gui_children.values()
+
+    def items(self):
+        return self.non_gui_children.items()
+
+    def _add_children(self, schema_data, first=True):
+        added_children = []
+        for children_schema in schema_data["children"]:
+            if children_schema["type"] in WRAPPER_TYPES:
+                _children_schema = copy.deepcopy(children_schema)
+                wrapper_children = self._add_children(
+                    children_schema["children"]
+                )
+                _children_schema["children"] = wrapper_children
+                added_children.append(_children_schema)
+                continue
+
+            child_obj = self.create_schema_object(children_schema, self)
+            self.children.append(child_obj)
+            added_children.append(child_obj)
+            if isinstance(child_obj, GUIEntity):
+                continue
+
+            if child_obj.key in self.non_gui_children:
+                raise KeyError("Duplicated key \"{}\"".format(child_obj.key))
+            self.non_gui_children[child_obj.key] = child_obj
+
+        if not first:
+            return added_children
+
+        for child_obj in added_children:
+            if isinstance(child_obj, BaseEntity):
+                continue
+            self.gui_wrappers.append(child_obj)
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (dict, )
+        self.children = []
+        self.non_gui_children = {}
+        self.gui_wrappers = []
+        self._add_children(self.schema_data)
+
+    def set_value(self, value):
+        for _key, _value in value.items():
+            self.non_gui_children[_key].set_value(_value)
+
+    def set_override_state(self, state):
+        self.override_state = state
+        for child_obj in self.non_gui_children.values():
+            child_obj.set_override_state(state)
+
+    @property
+    def child_has_studio_override(self):
+        pass
+
+    @property
+    def child_invalid(self):
+        pass
+
+    @property
+    def child_value_modified(self):
+        pass
+
+    @property
+    def child_overriden(self):
+        pass
+
+    def discard_changes(self):
+        pass
+
+    def get_invalid(self):
+        pass
+
+    def settings_value(self):
+        pass
+
+    def remove_overrides(self):
+        pass
+
+    def reset_to_pype_default(self):
+        pass
+
+    def set_as_overriden(self):
+        pass
+
+    def set_studio_default(self):
+        pass
+
+    def update_default_values(self, values):
+        for key, child_obj in self.non_gui_children.items():
+            child_obj.update_default_values(values[key])
+
+    def update_studio_values(self, parent_values):
+        pass
+
+    def update_project_values(self, parent_values):
+        pass
+
+
+class DictMutableKeysEntity(ItemEntity):
+    schema_types = ["dict-modifiable"]
+    _miss_arg = object()
+
+    def __getitem__(self, key):
+        return self.children_by_key[key]
+
+    def __setitem__(self, key, value):
+        if key in self.children_by_key:
+            self.children_by_key[key].set_value(value)
+        else:
+            self._add_child(key, value)
+
+    def __iter__(self):
+        for key in self.keys():
+            yield key
+
+    def pop(self, key, default=_miss_arg):
+        if key not in self.children_by_key:
+            if default is self._miss_arg:
+                raise KeyError("Key \"{}\" not found.".format(key))
+            return default
+
+        child_obj = self.children_by_key.pop(key)
+        self.children.remove(child_obj)
+        return child_obj
+
+    def get(self, key, default=None):
+        return self.non_gui_children.get(key, default)
+
+    def keys(self):
+        return self.non_gui_children.keys()
+
+    def values(self):
+        return self.non_gui_children.values()
+
+    def items(self):
+        return self.non_gui_children.items()
+
+    def _add_child(self, key, value):
+        new_child = self.create_schema_object(self.item_schema, self, True)
+
+        new_child.set_value(value)
+
+        self.children.append(new_child)
+        self.children_by_key[key] = new_child
+        return new_child
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (dict, )
+        self.children = []
+        self.children_by_key = {}
+        object_type = self.schema_data["object_type"]
+        if isinstance(object_type, dict):
+            self.item_schema = object_type
+        else:
+            # Backwards compatibility
+            self.item_schema = {
+                "type": object_type
+            }
+            input_modifiers = self.schema_data.get("input_modifiers") or {}
+            if input_modifiers:
+                self.log.warning((
+                    "Used deprecated key `input_modifiers` to define item."
+                    " Rather use `object_type` as dictionary with modifiers."
+                ))
+                self.item_schema.update(input_modifiers)
+
+    def set_value(self, value):
+        # TODO cleanup previous keys and values
+        pass
+
+    def set_override_state(self, state):
+        for child_obj in self.children_by_key.values():
+            child_obj.set_override_state(state)
+
+    @property
+    def child_has_studio_override(self):
+        pass
+
+    @property
+    def child_invalid(self):
+        pass
+
+    @property
+    def child_value_modified(self):
+        pass
+
+    @property
+    def child_overriden(self):
+        pass
+
+    def discard_changes(self):
+        pass
+
+    def get_invalid(self):
+        pass
+
+    def settings_value(self):
+        pass
+
+    def remove_overrides(self):
+        pass
+
+    def reset_to_pype_default(self):
+        pass
+
+    def set_as_overriden(self):
+        pass
+
+    def set_studio_default(self):
+        pass
+
+    def update_default_values(self, parent_values):
+        pass
+
+    def update_studio_values(self, parent_values):
+        pass
+
+    def update_project_values(self, parent_values):
+        pass
+
+
+class ListEntity(ItemEntity):
+    schema_types = ["list"]
+
+    def __iter__(self):
+        pass
+
+    def append(self, item):
+        pass
+
+    def extend(self, items):
+        pass
+
+    def clear(self):
+        pass
+
+    def pop(self, idx):
+        pass
+
+    def remove(self, item):
+        pass
+
+    def insert(self, idx, item):
+        pass
+
+    def reverse(self):
+        pass
+
+    def sort(self):
+        pass
+
+    def _add_children(self, schema_data, first=True):
+        added_children = []
+        for children_schema in schema_data["children"]:
+            if children_schema["type"] in WRAPPER_TYPES:
+                _children_schema = copy.deepcopy(children_schema)
+                wrapper_children = self._add_children(
+                    children_schema["children"]
+                )
+                _children_schema["children"] = wrapper_children
+                added_children.append(_children_schema)
+                continue
+
+            child_obj = self.create_schema_object(children_schema, self, True)
+            self.children.append(child_obj)
+            added_children.append(child_obj)
+            if isinstance(child_obj, GUIEntity):
+                continue
+
+            if child_obj.key in self.non_gui_children:
+                raise KeyError("Duplicated key \"{}\"".format(child_obj.key))
+            self.non_gui_children[child_obj.key] = child_obj
+
+        if not first:
+            return added_children
+
+        for child_obj in added_children:
+            if isinstance(child_obj, BaseEntity):
+                continue
+            self.gui_wrappers.append(child_obj)
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (list, )
+        self.children = []
+
+        item_schema = self.schema_data["object_type"]
+        if not isinstance(item_schema, dict):
+            item_schema = {"type": item_schema}
+        self.item_schema = item_schema
+
+        # GUI attributes
+        self.use_label_wrap = self.schema_data.get("use_label_wrap") or False
+        # Used only if `use_label_wrap` is set to True
+        self.collapsible = self.schema_data.get("collapsible") or True
+        self.collapsed = self.schema_data.get("collapsed") or False
+
+    def set_value(self, value):
+        pass
+
+    def set_override_state(self, state):
+        for child_obj in self.non_gui_children:
+            child_obj.set_override_state(state)
+
+    @property
+    def child_has_studio_override(self):
+        pass
+
+    @property
+    def child_invalid(self):
+        pass
+
+    @property
+    def child_value_modified(self):
+        pass
+
+    @property
+    def child_overriden(self):
+        pass
+
+    def discard_changes(self):
+        pass
+
+    def get_invalid(self):
+        pass
+
+    def settings_value(self):
+        pass
+
+    def remove_overrides(self):
+        pass
+
+    def reset_to_pype_default(self):
+        pass
+
+    def set_as_overriden(self):
+        pass
+
+    def set_studio_default(self):
+        pass
+
+    def update_default_values(self, parent_values):
+        pass
+
+    def update_studio_values(self, parent_values):
+        pass
+
+    def update_project_values(self, parent_values):
+        pass
+
+
+class InputEntity(ItemEntity):
+    def __eq__(self, other):
+        if isinstance(other, ItemEntity):
+            return self.current_value == other.current_value
+        return self.current_value == other
+
+    def update_default_values(self, value):
+        self.default_values = value
+
+    def update_project_values(self, value):
+        self.studio_override_value = value
+
+    def update_studio_values(self, value):
+        self.project_override_value = value
+
+    @property
+    def child_has_studio_override(self):
+        return self.has_studio_override
+
+    @property
+    def child_invalid(self):
+        return self.is_invalid
+
+    @property
+    def child_value_modified(self):
+        return self.value_is_modified
+
+    @property
+    def child_overriden(self):
+        return self.is_overriden
+
+    def settings_value(self):
+        return self.current_value
+
+    def get_invalid(self):
+        if self.is_invalid:
+            return [self]
+
+    def remove_overrides(self):
+        current_value = self.default_value
+        if self.override_state is OverrideState.STUDIO:
+            self.has_studio_override = False
+
+        elif self.override_state is OverrideState.PROJECT:
+            self.has_project_override = False
+            if self.studio_override_value is not NOT_SET:
+                current_value = self.studio_override_value
+
+        self.current_value = current_value
+
+    def reset_to_pype_default(self):
+        if self.override_state is OverrideState.PROJECT:
+            raise ValueError(
+                "Can't reset to Pype defaults on project overrides state."
+            )
+        self.has_studio_override = False
+        self.set_value(self.default_value)
+
+    def set_as_overriden(self):
+        self.is_overriden = True
+
+    def set_studio_default(self):
+        self.set_value(self.studio_override_value)
+
+    def discard_changes(self):
+        self.has_studio_override = self.had_studio_override
+        self.has_project_override = self.had_project_override
+
+
+class GUIEntity(ItemEntity):
+    gui_type = True
+    schema_types = ["divider", "splitter", "label"]
+    child_has_studio_override = False
+    child_invalid = False
+    child_value_modified = False
+    child_overriden = False
+
+    def item_initalization(self):
+        self.valid_value_types = tuple()
+        self.require_key = False
+
+    def set_value(self, value):
+        pass
+
+    def set_override_state(self, state):
+        pass
+
+    def discard_changes(self):
+        pass
+
+    def get_invalid(self):
+        pass
+
+    def settings_value(self):
+        pass
+
+    def remove_overrides(self):
+        pass
+
+    def reset_to_pype_default(self):
+        pass
+
+    def set_as_overriden(self):
+        pass
+
+    def set_studio_default(self):
+        pass
+
+    def update_default_values(self, parent_values):
+        pass
+
+    def update_studio_values(self, parent_values):
+        pass
+
+    def update_project_values(self, parent_values):
+        pass
+
+
+class TextEntity(InputEntity):
+    schema_types = ["text"]
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (str, )
+
+    def set_value(self, value):
+        self.current_value = value
+
+
+class PathEntity(InputEntity):
+    schema_types = ["path-widget"]
+    platforms = ("windows", "darwin", "linux")
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.multiplatform = self.schema_data.get("multiplatform", False)
+        self.multipath = self.schema_data.get("multipath", False)
+        self.with_arguments = self.schema_data.get("with_arguments", False)
+        if self.multiplatform:
+            valid_value_types = (dict, )
+        elif self.multipath:
+            valid_value_types = (list, )
+        else:
+            valid_value_types = (str, )
+
+        self.valid_value_types = valid_value_types
+
+    def set_value(self, value):
+        if value == self.current_value:
+            return
+
+        self.current_value = value
+        self.on_value_change()
+
+    def on_value_change(self):
+        if self.override_state is OverrideState.STUDIO:
+            self.value_is_modified = (
+                self.current_value != self.studio_override_value
+            )
+        elif self.override_state is OverrideState.PROJECT:
+            self.value_is_modified = (
+                self.current_value != self.project_override_value
+            )
+
+
+class RawJsonEntity(InputEntity):
+    schema_types = ["raw-json"]
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (list, dict)
+
+    def set_value(self, value):
+        self.current_value = value
+
+
+class NumberEntity(InputEntity):
+    schema_types = ["number"]
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (int, float)
+
+    def set_value(self, value):
+        self.current_value = value
+
+
+class BoolEntity(InputEntity):
+    schema_types = ["boolean"]
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.valid_value_types = (bool, )
+
+    def set_value(self, value):
+        self.current_value = value
+
+
+class EnumEntity(InputEntity):
+    schema_types = ["enum"]
+
+    def item_initalization(self):
+        # Children are stored by key as keys are immutable and are defined by
+        # schema
+        self.multiselection = self.schema_data.get("multiselection", False)
+        self.enum_items = self.schema_data["enum_items"]
+        if not self.enum_items:
+            raise ValueError("Attribute `enum_items` is not defined.")
+
+        valid_value_types = set()
+        for item in self.enum_items:
+            valid_value_types.add(type(item))
+
+        self.valid_value_types = tuple(valid_value_types)
+
+    def set_value(self, value):
+        if self.multiselection:
+            if not isinstance(value, list):
+                if isinstance(value, (set, tuple)):
+                    value = list(value)
+                else:
+                    value = [value]
+            check_values = value
+        else:
+            check_values = [value]
+
+        for item in check_values:
+            if item not in self.enum_items:
+                raise ValueError(
+                    "Invalid value \"{}\". Expected: {}".format(
+                        item, self.enum_items
+                    )
+                )
+        self.current_value = value
+
+
+if __name__ == "__main__":
+    from lib import gui_schema
+    schema_data = gui_schema("system_schema", "schema_main")
+    root = RootEntity(schema_data)
+    a = root["general"]["studio_name"]
+    print(a.current_value)

pype/settings/entities/lib.py

@@ -0,0 +1,599 @@
+import os
+import re
+import json
+import copy
+from constants import (
+    M_OVERRIDEN_KEY,
+    M_ENVIRONMENT_KEY,
+    M_DYNAMIC_KEY_LABEL
+)
+from queue import Queue
+
+
+# Singleton database of available inputs
+class TypeToKlass:
+    types = {}
+
+
+NOT_SET = type("NOT_SET", (), {"__bool__": lambda obj: False})()
+METADATA_KEY = type("METADATA_KEY", (), {})()
+OVERRIDE_VERSION = 1
+CHILD_OFFSET = 15
+
+key_pattern = re.compile(r"(\{.*?[^{0]*\})")
+
+
+def convert_gui_data_with_metadata(data, ignored_keys=None):
+    if not data or not isinstance(data, dict):
+        return data
+
+    if ignored_keys is None:
+        ignored_keys = tuple()
+
+    output = {}
+    if METADATA_KEY in data:
+        metadata = data.pop(METADATA_KEY)
+        for key, value in metadata.items():
+            if key in ignored_keys or key == "groups":
+                continue
+
+            if key == "environments":
+                output[M_ENVIRONMENT_KEY] = value
+            elif key == "dynamic_key_label":
+                output[M_DYNAMIC_KEY_LABEL] = value
+            else:
+                raise KeyError("Unknown metadata key \"{}\"".format(key))
+
+    for key, value in data.items():
+        output[key] = convert_gui_data_with_metadata(value, ignored_keys)
+    return output
+
+
+def convert_data_to_gui_data(data, first=True):
+    if not data or not isinstance(data, dict):
+        return data
+
+    output = {}
+    if M_ENVIRONMENT_KEY in data:
+        data.pop(M_ENVIRONMENT_KEY)
+
+    if M_DYNAMIC_KEY_LABEL in data:
+        if METADATA_KEY not in data:
+            data[METADATA_KEY] = {}
+        data[METADATA_KEY]["dynamic_key_label"] = data.pop(M_DYNAMIC_KEY_LABEL)
+
+    for key, value in data.items():
+        output[key] = convert_data_to_gui_data(value, False)
+
+    return output
+
+
+def convert_gui_data_to_overrides(data, first=True):
+    if not data or not isinstance(data, dict):
+        return data
+
+    output = {}
+    if first:
+        output["__override_version__"] = OVERRIDE_VERSION
+        data = convert_gui_data_with_metadata(data)
+
+    if METADATA_KEY in data:
+        metadata = data.pop(METADATA_KEY)
+        for key, value in metadata.items():
+            if key == "groups":
+                output[M_OVERRIDEN_KEY] = value
+            else:
+                raise KeyError("Unknown metadata key \"{}\"".format(key))
+
+    for key, value in data.items():
+        output[key] = convert_gui_data_to_overrides(value, False)
+    return output
+
+
+def convert_overrides_to_gui_data(data, first=True):
+    if not data or not isinstance(data, dict):
+        return data
+
+    if first:
+        data = convert_data_to_gui_data(data)
+
+    output = {}
+    if M_OVERRIDEN_KEY in data:
+        groups = data.pop(M_OVERRIDEN_KEY)
+        if METADATA_KEY not in output:
+            output[METADATA_KEY] = {}
+        output[METADATA_KEY]["groups"] = groups
+
+    for key, value in data.items():
+        output[key] = convert_overrides_to_gui_data(value, False)
+
+    return output
+
+
+def _fill_schema_template_data(
+    template, template_data, required_keys=None, missing_keys=None
+):
+    first = False
+    if required_keys is None:
+        first = True
+        required_keys = set()
+        missing_keys = set()
+
+        _template = []
+        default_values = {}
+        for item in template:
+            if isinstance(item, dict) and "__default_values__" in item:
+                default_values = item["__default_values__"]
+            else:
+                _template.append(item)
+        template = _template
+
+        for key, value in default_values.items():
+            if key not in template_data:
+                template_data[key] = value
+
+    if not template:
+        output = template
+
+    elif isinstance(template, list):
+        output = []
+        for item in template:
+            output.append(_fill_schema_template_data(
+                item, template_data, required_keys, missing_keys
+            ))
+
+    elif isinstance(template, dict):
+        output = {}
+        for key, value in template.items():
+            output[key] = _fill_schema_template_data(
+                value, template_data, required_keys, missing_keys
+            )
+
+    elif isinstance(template, str):
+        # TODO find much better way how to handle filling template data
+        for replacement_string in key_pattern.findall(template):
+            key = str(replacement_string[1:-1])
+            required_keys.add(key)
+            if key not in template_data:
+                missing_keys.add(key)
+                continue
+
+            value = template_data[key]
+            if replacement_string == template:
+                # Replace the value with value from templates data
+                # - with this is possible to set value with different type
+                template = value
+            else:
+                # Only replace the key in string
+                template = template.replace(replacement_string, value)
+        output = template
+
+    else:
+        output = template
+
+    if first and missing_keys:
+        raise SchemaTemplateMissingKeys(missing_keys, required_keys)
+
+    return output
+
+
+def _fill_schema_template(child_data, schema_collection, schema_templates):
+    template_name = child_data["name"]
+    template = schema_templates.get(template_name)
+    if template is None:
+        if template_name in schema_collection:
+            raise KeyError((
+                "Schema \"{}\" is used as `schema_template`"
+            ).format(template_name))
+        raise KeyError("Schema template \"{}\" was not found".format(
+            template_name
+        ))
+
+    # Default value must be dictionary (NOT list)
+    # - empty list would not add any item if `template_data` are not filled
+    template_data = child_data.get("template_data") or {}
+    if isinstance(template_data, dict):
+        template_data = [template_data]
+
+    output = []
+    for single_template_data in template_data:
+        try:
+            filled_child = _fill_schema_template_data(
+                template, single_template_data
+            )
+
+        except SchemaTemplateMissingKeys as exc:
+            raise SchemaTemplateMissingKeys(
+                exc.missing_keys, exc.required_keys, template_name
+            )
+
+        for item in filled_child:
+            filled_item = _fill_inner_schemas(
+                item, schema_collection, schema_templates
+            )
+            if filled_item["type"] == "schema_template":
+                output.extend(_fill_schema_template(
+                    filled_item, schema_collection, schema_templates
+                ))
+            else:
+                output.append(filled_item)
+    return output
+
+
+def _fill_inner_schemas(schema_data, schema_collection, schema_templates):
+    if schema_data["type"] == "schema":
+        raise ValueError("First item in schema data can't be schema.")
+
+    children_key = "children"
+    object_type_key = "object_type"
+    for item_key in (children_key, object_type_key):
+        children = schema_data.get(item_key)
+        if not children:
+            continue
+
+        if object_type_key == item_key:
+            if not isinstance(children, dict):
+                continue
+            children = [children]
+
+        new_children = []
+        for child in children:
+            child_type = child["type"]
+            if child_type == "schema":
+                schema_name = child["name"]
+                if schema_name not in schema_collection:
+                    if schema_name in schema_templates:
+                        raise KeyError((
+                            "Schema template \"{}\" is used as `schema`"
+                        ).format(schema_name))
+                    raise KeyError(
+                        "Schema \"{}\" was not found".format(schema_name)
+                    )
+
+                filled_child = _fill_inner_schemas(
+                    schema_collection[schema_name],
+                    schema_collection,
+                    schema_templates
+                )
+
+            elif child_type == "schema_template":
+                for filled_child in _fill_schema_template(
+                    child, schema_collection, schema_templates
+                ):
+                    new_children.append(filled_child)
+                continue
+
+            else:
+                filled_child = _fill_inner_schemas(
+                    child, schema_collection, schema_templates
+                )
+
+            new_children.append(filled_child)
+
+        if item_key == object_type_key:
+            if len(new_children) != 1:
+                raise KeyError((
+                    "Failed to fill object type with type: {} | name {}"
+                ).format(
+                    child_type, str(child.get("name"))
+                ))
+            new_children = new_children[0]
+
+        schema_data[item_key] = new_children
+    return schema_data
+
+
+class SchemaTemplateMissingKeys(Exception):
+    def __init__(self, missing_keys, required_keys, template_name=None):
+        self.missing_keys = missing_keys
+        self.required_keys = required_keys
+        if template_name:
+            msg = f"Schema template \"{template_name}\" require more keys.\n"
+        else:
+            msg = ""
+        msg += "Required keys: {}\nMissing keys: {}".format(
+            self.join_keys(required_keys),
+            self.join_keys(missing_keys)
+        )
+        super(SchemaTemplateMissingKeys, self).__init__(msg)
+
+    def join_keys(self, keys):
+        return ", ".join([
+            f"\"{key}\"" for key in keys
+        ])
+
+
+class SchemaMissingFileInfo(Exception):
+    def __init__(self, invalid):
+        full_path_keys = []
+        for item in invalid:
+            full_path_keys.append("\"{}\"".format("/".join(item)))
+
+        msg = (
+            "Schema has missing definition of output file (\"is_file\" key)"
+            " for keys. [{}]"
+        ).format(", ".join(full_path_keys))
+        super(SchemaMissingFileInfo, self).__init__(msg)
+
+
+class SchemeGroupHierarchyBug(Exception):
+    def __init__(self, invalid):
+        full_path_keys = []
+        for item in invalid:
+            full_path_keys.append("\"{}\"".format("/".join(item)))
+
+        msg = (
+            "Items with attribute \"is_group\" can't have another item with"
+            " \"is_group\" attribute as child. Error happened for keys: [{}]"
+        ).format(", ".join(full_path_keys))
+        super(SchemeGroupHierarchyBug, self).__init__(msg)
+
+
+class SchemaDuplicatedKeys(Exception):
+    def __init__(self, invalid):
+        items = []
+        for key_path, keys in invalid.items():
+            joined_keys = ", ".join([
+                "\"{}\"".format(key) for key in keys
+            ])
+            items.append("\"{}\" ({})".format(key_path, joined_keys))
+
+        msg = (
+            "Schema items contain duplicated keys in one hierarchy level. {}"
+        ).format(" || ".join(items))
+        super(SchemaDuplicatedKeys, self).__init__(msg)
+
+
+class SchemaDuplicatedEnvGroupKeys(Exception):
+    def __init__(self, invalid):
+        items = []
+        for key_path, keys in invalid.items():
+            joined_keys = ", ".join([
+                "\"{}\"".format(key) for key in keys
+            ])
+            items.append("\"{}\" ({})".format(key_path, joined_keys))
+
+        msg = (
+            "Schema items contain duplicated environment group keys. {}"
+        ).format(" || ".join(items))
+        super(SchemaDuplicatedEnvGroupKeys, self).__init__(msg)
+
+
+def file_keys_from_schema(schema_data):
+    output = []
+    item_type = schema_data["type"]
+    klass = TypeToKlass.types[item_type]
+    if not klass.is_input_type:
+        return output
+
+    keys = []
+    key = schema_data.get("key")
+    if key:
+        keys.append(key)
+
+    for child in schema_data["children"]:
+        if child.get("is_file"):
+            _keys = copy.deepcopy(keys)
+            _keys.append(child["key"])
+            output.append(_keys)
+            continue
+
+        for result in file_keys_from_schema(child):
+            _keys = copy.deepcopy(keys)
+            _keys.extend(result)
+            output.append(_keys)
+    return output
+
+
+def validate_all_has_ending_file(schema_data, is_top=True):
+    item_type = schema_data["type"]
+    klass = TypeToKlass.types[item_type]
+    if not klass.is_input_type:
+        return None
+
+    if schema_data.get("is_file"):
+        return None
+
+    children = schema_data.get("children")
+    if not children:
+        return [[schema_data["key"]]]
+
+    invalid = []
+    keyless = "key" not in schema_data
+    for child in children:
+        result = validate_all_has_ending_file(child, False)
+        if result is None:
+            continue
+
+        if keyless:
+            invalid.extend(result)
+        else:
+            for item in result:
+                new_invalid = [schema_data["key"]]
+                new_invalid.extend(item)
+                invalid.append(new_invalid)
+
+    if not invalid:
+        return None
+
+    if not is_top:
+        return invalid
+
+    raise SchemaMissingFileInfo(invalid)
+
+
+def validate_is_group_is_unique_in_hierarchy(
+    schema_data, any_parent_is_group=False, keys=None
+):
+    is_top = keys is None
+    if keys is None:
+        keys = []
+
+    keyless = "key" not in schema_data
+
+    if not keyless:
+        keys.append(schema_data["key"])
+
+    invalid = []
+    is_group = schema_data.get("is_group")
+    if is_group and any_parent_is_group:
+        invalid.append(copy.deepcopy(keys))
+
+    if is_group:
+        any_parent_is_group = is_group
+
+    children = schema_data.get("children")
+    if not children:
+        return invalid
+
+    for child in children:
+        result = validate_is_group_is_unique_in_hierarchy(
+            child, any_parent_is_group, copy.deepcopy(keys)
+        )
+        if not result:
+            continue
+
+        invalid.extend(result)
+
+    if invalid and is_group and keys not in invalid:
+        invalid.append(copy.deepcopy(keys))
+
+    if not is_top:
+        return invalid
+
+    if invalid:
+        raise SchemeGroupHierarchyBug(invalid)
+
+
+def validate_keys_are_unique(schema_data, keys=None):
+    children = schema_data.get("children")
+    if not children:
+        return
+
+    is_top = keys is None
+    if keys is None:
+        keys = [schema_data["key"]]
+    else:
+        keys.append(schema_data["key"])
+
+    child_queue = Queue()
+    for child in children:
+        child_queue.put(child)
+
+    child_inputs = []
+    while not child_queue.empty():
+        child = child_queue.get()
+        if "key" not in child:
+            _children = child.get("children") or []
+            for _child in _children:
+                child_queue.put(_child)
+        else:
+            child_inputs.append(child)
+
+    duplicated_keys = set()
+    child_keys = set()
+    for child in child_inputs:
+        key = child["key"]
+        if key in child_keys:
+            duplicated_keys.add(key)
+        else:
+            child_keys.add(key)
+
+    invalid = {}
+    if duplicated_keys:
+        joined_keys = "/".join(keys)
+        invalid[joined_keys] = duplicated_keys
+
+    for child in child_inputs:
+        result = validate_keys_are_unique(child, copy.deepcopy(keys))
+        if result:
+            invalid.update(result)
+
+    if not is_top:
+        return invalid
+
+    if invalid:
+        raise SchemaDuplicatedKeys(invalid)
+
+
+def validate_environment_groups_uniquenes(
+    schema_data, env_groups=None, keys=None
+):
+    is_first = False
+    if env_groups is None:
+        is_first = True
+        env_groups = {}
+        keys = []
+
+    my_keys = copy.deepcopy(keys)
+    key = schema_data.get("key")
+    if key:
+        my_keys.append(key)
+
+    env_group_key = schema_data.get("env_group_key")
+    if env_group_key:
+        if env_group_key not in env_groups:
+            env_groups[env_group_key] = []
+        env_groups[env_group_key].append("/".join(my_keys))
+
+    children = schema_data.get("children")
+    if not children:
+        return
+
+    for child in children:
+        validate_environment_groups_uniquenes(
+            child, env_groups, copy.deepcopy(my_keys)
+        )
+
+    if is_first:
+        invalid = {}
+        for env_group_key, key_paths in env_groups.items():
+            if len(key_paths) > 1:
+                invalid[env_group_key] = key_paths
+
+        if invalid:
+            raise SchemaDuplicatedEnvGroupKeys(invalid)
+
+
+def validate_schema(schema_data):
+    return
+    # validate_all_has_ending_file(schema_data)
+    # validate_is_group_is_unique_in_hierarchy(schema_data)
+    # validate_keys_are_unique(schema_data)
+    # validate_environment_groups_uniquenes(schema_data)
+
+
+def gui_schema(subfolder, main_schema_name):
+    dirpath = os.path.join(
+        os.path.dirname(__file__),
+        "schemas",
+        subfolder
+    )
+    loaded_schemas = {}
+    loaded_schema_templates = {}
+    for root, _, filenames in os.walk(dirpath):
+        for filename in filenames:
+            basename, ext = os.path.splitext(filename)
+            if ext != ".json":
+                continue
+
+            filepath = os.path.join(root, filename)
+            with open(filepath, "r") as json_stream:
+                try:
+                    schema_data = json.load(json_stream)
+                except Exception as exc:
+                    raise Exception((
+                        f"Unable to parse JSON file {filepath}\n{exc}"
+                    )) from exc
+            if isinstance(schema_data, list):
+                loaded_schema_templates[basename] = schema_data
+            else:
+                loaded_schemas[basename] = schema_data
+
+    main_schema = _fill_inner_schemas(
+        loaded_schemas[main_schema_name],
+        loaded_schemas,
+        loaded_schema_templates
+    )
+    validate_schema(main_schema)
+    return main_schema

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

@@ -0,0 +1,76 @@
+{
+    "key": "project",
+    "type": "dict",
+    "children": [
+        {
+            "type": "anatomy",
+            "key": "project_anatomy",
+            "children": [
+                {
+                    "type": "anatomy_roots",
+                    "key": "roots",
+                    "label": "Roots",
+                    "is_file": true
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_anatomy_templates"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_anatomy_attributes"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_anatomy_imageio"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "project_settings",
+            "children": [
+                {
+                    "type": "schema",
+                    "name": "schema_project_global"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_ftrack"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_maya"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_nuke"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_hiero"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_harmony"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_celaction"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_resolve"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_standalonepublisher"
+                },
+                {
+                    "type": "schema",
+                    "name": "schema_project_unreal"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_plugins.json

@@ -0,0 +1,54 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "plugins",
+    "label": "Plugins",
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "standalonepublisher",
+            "label": "Standalone Publisher",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "publish",
+                    "label": "Publish plugins",
+                    "is_file": true,
+                    "children": [
+                        {
+                            "type": "dict",
+                            "collapsable": true,
+                            "key": "ExtractThumbnailSP",
+                            "label": "ExtractThumbnailSP",
+                            "is_group": true,
+                            "children": [
+                                {
+                                    "type": "dict",
+                                    "collapsable": false,
+                                    "key": "ffmpeg_args",
+                                    "label": "ffmpeg_args",
+                                    "children": [
+                                        {
+                                            "type": "list",
+                                            "object_type": "text",
+                                            "key": "input",
+                                            "label": "input"
+                                        },
+                                        {
+                                            "type": "list",
+                                            "object_type": "text",
+                                            "key": "output",
+                                            "label": "output"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_celaction.json

@@ -0,0 +1,62 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "celaction",
+    "label": "CelAction",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "publish",
+            "label": "Publish plugins",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ExtractCelactionDeadline",
+                    "label": "ExtractCelactionDeadline",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "text",
+                            "key": "deadline_department",
+                            "label": "Deadline apartment"
+                        },
+                        {
+                            "type": "number",
+                            "key": "deadline_priority",
+                            "label": "Deadline priority"
+                        },
+                        {
+                            "type": "text",
+                            "key": "deadline_pool",
+                            "label": "Deadline pool"
+                        },
+                        {
+                            "type": "text",
+                            "key": "deadline_pool_secondary",
+                            "label": "Deadline pool (secondary)"
+                        },
+                        {
+                            "type": "text",
+                            "key": "deadline_group",
+                            "label": "Deadline Group"
+                        },
+                        {
+                            "type": "number",
+                            "key": "deadline_chunk_size",
+                            "label": "Deadline Chunk size"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_ftrack.json

@@ -0,0 +1,644 @@
+{
+    "type": "dict",
+    "key": "ftrack",
+    "label": "Ftrack",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "is_file": true,
+    "children": [
+        {
+            "type": "splitter"
+        },
+        {
+            "type": "label",
+            "label": "Additional Ftrack paths"
+        },
+        {
+            "type": "list",
+            "key": "ftrack_actions_path",
+            "label": "Action paths",
+            "object_type": "text"
+        },
+        {
+            "type": "list",
+            "key": "ftrack_events_path",
+            "label": "Event paths",
+            "object_type": "text"
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "type": "dict",
+            "key": "events",
+            "label": "Server Actions/Events",
+            "children": [
+                {
+                    "type": "dict",
+                    "key": "sync_to_avalon",
+                    "label": "Sync to avalon",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "label",
+                            "label": "Allow name and hierarchy change only if following statuses are on all children tasks"
+                        },
+                        {
+                            "type": "list",
+                            "key": "statuses_name_change",
+                            "label": "Statuses",
+                            "object_type": {
+                                "type": "text",
+                                "multiline": false
+                            }
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "sync_hier_entity_attributes",
+                    "label": "Sync Hierarchical and Entity Attributes",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "interest_entity_types",
+                            "label": "Entity types of interest",
+                            "object_type": {
+                                "type": "text",
+                                "multiline": false
+                            }
+                        },
+                        {
+                            "type": "list",
+                            "key": "interest_attributes",
+                            "label": "Attributes to sync",
+                            "object_type": {
+                                "type": "text",
+                                "multiline": false
+                            }
+                        },
+                        {
+                            "type": "separator"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "action_enabled",
+                            "label": "Enable Action"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles for action",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "thumbnail_updates",
+                    "label": "Update Hierarchy thumbnails",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "label",
+                            "label": "Push thumbnail from version, up through multiple hierarchy levels."
+                        },
+                        {
+                            "type": "number",
+                            "key": "levels",
+                            "label": "Levels"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "user_assignment",
+                    "label": "Run script on user assignments",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "status_update",
+                    "label": "Update status on task action",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "key": "mapping",
+                            "type": "dict-modifiable",
+                            "object_type": {
+                                "type": "list",
+                                "object_type": "text"
+                            }
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "status_task_to_parent",
+                    "label": "Sync status from Task to Parent",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "label",
+                            "label": "List of parent object types where this is triggered (\"Shot\", \"Asset Build\", etc.). Skipped if list is empty."
+                        },
+                        {
+                            "type": "list",
+                            "object_type": "text",
+                            "key": "parent_object_types",
+                            "label": "Object types"
+                        },
+                        {
+                            "key": "parent_status_match_all_task_statuses",
+                            "type": "dict-modifiable",
+                            "label": "Change parent if all tasks match",
+                            "object_type": {
+                                "type": "list",
+                                "object_type": "text"
+                            }
+                        },
+                        {
+                            "type": "list",
+                            "key": "parent_status_by_task_status",
+                            "label": "Change parent status if a single task matches",
+                            "use_label_wrap": true,
+                            "object_type": {
+                                "type": "dict",
+                                "children": [
+                                    {
+                                        "type": "text",
+                                        "label": "New parent status",
+                                        "key": "new_status"
+                                    },
+                                    {
+                                        "type": "separator"
+                                    },
+                                    {
+                                        "type": "list",
+                                        "label": "Task status",
+                                        "key": "task_statuses",
+                                        "object_type": "text"
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "status_task_to_version",
+                    "label": "Sync status from Task to Version",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "dict-modifiable",
+                            "key": "mapping",
+                            "object_type":
+                            {
+                                "type": "list",
+                                "object_type": "text"
+                            }
+                        },
+                        {
+                            "type": "label",
+                            "label": "<b>Limit<b/> status changes to entered asset types. Limitation is ignored if nothing is entered."
+                        },
+                        {
+                            "type": "list",
+                            "key": "asset_types_filter",
+                            "label": "Asset types (short)",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "status_version_to_task",
+                    "label": "Sync status from Version to Task",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "label",
+                            "label": "<b>Change Task status based on a changed Version status.</b><br/>Version's new status on the <b>left</b> will trigger a change of a task status to the first available from the list on <b>right</b>.<br/> - if no status from the list is available it will use the same status as the version."
+                        },
+                        {
+                            "type": "dict-modifiable",
+                            "key": "mapping",
+                            "object_type": {
+                                "type": "list",
+                                "object_type": "text"
+                            }
+                        },
+                        {
+                            "type": "separator"
+                        },
+                        {
+                            "type": "label",
+                            "label": "<b>Disable<b/> event if status was changed on specific Asset type."
+                        },
+                        {
+                            "type": "list",
+                            "label": "Asset types (short)",
+                            "key": "asset_types_to_skip",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "first_version_status",
+                    "label": "Set status on first created version",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "text",
+                            "key": "status",
+                            "label": "Status"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "next_task_update",
+                    "label": "Update status on next task",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "label",
+                            "label": "Change status on next task by <b>task types order</b> when task status state changed to \"Done\". All tasks with same Task type must be \"Done\"."
+                        },
+                        {
+                            "type": "label",
+                            "label": "Mapping of next task status changes <b>From</b> -> <b>To</b>."
+                        },
+                        {
+                            "type": "dict-modifiable",
+                            "key": "mapping",
+                            "object_type": {
+                                "type": "text"
+                            }
+                        },
+                        {
+                            "type": "separator"
+                        },
+                        {
+                            "type": "label",
+                            "label": "Status names that are ignored on \"Done\" check (e.g. \"Omitted\")."
+                        },
+                        {
+                            "type": "list",
+                            "key": "ignored_statuses",
+                            "object_type": "text"
+                        },
+                        {
+                            "type": "separator"
+                        },
+                        {
+                            "type": "label",
+                            "label": "Allow to break rule that all tasks with same Task type must be \"Done\" and change statuses with same type tasks ordered by name."
+                        },
+                        {
+                            "label": "Name sorting",
+                            "type": "boolean",
+                            "key": "name_sorting"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "user_handlers",
+            "label": "User Actions/Events",
+            "children": [
+                {
+                    "type": "dict",
+                    "key": "application_launch_statuses",
+                    "label": "Application - Status change on launch",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "label",
+                            "label": "<b>Do not change status if current status is:</b>"
+                        },
+                        {
+                            "type": "list",
+                            "key": "ignored_statuses",
+                            "object_type": "text"
+                        },
+                        {
+                            "type": "label",
+                            "label": "Change task's status to <b>left side</b> if current task status is in list on <b>right side</b>."
+                        },
+                        {
+                            "type": "dict-modifiable",
+                            "key": "status_change",
+                            "object_type": {
+                                "type": "list",
+                                "object_type": "text"
+                            }
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "create_update_attributes",
+                    "label": "Create/Update Avalon Attributes",
+                    "children": [
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "prepare_project",
+                    "label": "Prepare Project",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "clean_hierarchical_attr",
+                    "label": "Clean hierarchical custom attributes",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "delete_asset_subset",
+                    "label": "Delete Asset/Subsets",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "delete_old_versions",
+                    "label": "Delete old versions",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "delivery_action",
+                    "label": "Delivery",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "store_thubmnail_to_avalon",
+                    "label": "Store Thumbnails to avalon",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "job_killer",
+                    "label": "Job Killer",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "sync_to_avalon_local",
+                    "label": "Sync to avalon (local) - For development",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "seed_project",
+                    "label": "Seed Debug Project",
+                    "checkbox_key": "enabled",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "key": "role_list",
+                            "label": "Roles",
+                            "object_type": "text"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "publish",
+            "label": "Publish plugins",
+            "is_file": true,
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "IntegrateFtrackNote",
+                    "label": "IntegrateFtrackNote",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "text",
+                            "key": "note_with_intent_template",
+                            "label": "Note with intent template"
+                        },
+                        {
+                            "type": "list",
+                            "object_type": "text",
+                            "key": "note_labels",
+                            "label": "Note labels"
+                        }
+                    ]
+                },
+
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ValidateFtrackAttributes",
+                    "label": "ValidateFtrackAttributes",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "raw-json",
+                            "key": "ftrack_custom_attributes",
+                            "label": "Custom attributes to validate"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_global.json

@@ -0,0 +1,33 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "global",
+    "label": "Global",
+    "is_file": true,
+    "children": [
+        {
+            "type": "schema",
+            "name": "schema_global_publish"
+        },
+        {
+            "type": "schema",
+            "name": "schema_global_tools"
+        },
+
+    {
+        "type": "collapsible-wrap",
+        "label": "Project Folder Structure",
+        "children": [
+            {
+                "type": "raw-json",
+                "key": "project_folder_structure"
+            }
+        ]
+    },
+
+    {
+        "type": "schema",
+        "name": "schema_project_syncserver"
+    }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_harmony.json

@@ -0,0 +1,34 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "harmony",
+    "label": "Harmony",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "publish",
+            "label": "Publish plugins",
+            "children": []
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "general",
+            "label": "General",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "skip_resolution_check",
+                    "label": "Skip Resolution Check"
+                },
+                {
+                    "type": "boolean",
+                    "key": "skip_timelines_check",
+                    "label": "Skip Timeliene Check"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_hiero.json

@@ -0,0 +1,57 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "hiero",
+    "label": "Hiero",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "publish",
+            "label": "Publish plugins",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "CollectInstanceVersion",
+                    "label": "Collect Instance Version",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ExtractReviewCutUpVideo",
+                    "label": "Extract Review Cut Up Video",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "list",
+                            "object_type": "text",
+                            "key": "tags_addition",
+                            "label": "Tags addition"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "schema",
+            "name": "schema_publish_gui_filter"
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_maya.json

@@ -0,0 +1,29 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "maya",
+    "label": "Maya",
+    "is_file": true,
+    "children": [
+        {
+            "type": "schema",
+            "name": "schema_maya_capture"
+        },
+        {
+            "type": "schema",
+            "name": "schema_maya_publish"
+        },
+        {
+            "type": "schema",
+            "name": "schema_maya_load"
+        },
+        {
+            "type": "schema",
+            "name": "schema_workfile_build"
+        },
+        {
+            "type": "schema",
+            "name": "schema_publish_gui_filter"
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_nuke.json

@@ -0,0 +1,179 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "nuke",
+    "label": "Nuke",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "create",
+            "label": "Create plugins",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": false,
+                    "key": "CreateWriteRender",
+                    "label": "CreateWriteRender",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "text",
+                            "key": "fpath_template",
+                            "label": "Path template"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": false,
+                    "key": "CreateWritePrerender",
+                    "label": "CreateWritePrerender",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "text",
+                            "key": "fpath_template",
+                            "label": "Path template"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "publish",
+            "label": "Publish plugins",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ExtractThumbnail",
+                    "label": "ExtractThumbnail",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "raw-json",
+                            "key": "nodes",
+                            "label": "Nodes"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ValidateKnobs",
+                    "label": "ValidateKnobs",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "raw-json",
+                            "key": "knobs",
+                            "label": "Knobs"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ExtractReviewDataLut",
+                    "label": "ExtractReviewDataLut",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "checkbox_key": "enabled",
+                    "key": "ExtractReviewDataMov",
+                    "label": "ExtractReviewDataMov",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "enabled",
+                            "label": "Enabled"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "viewer_lut_raw",
+                            "label": "Viewer LUT raw"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "ExtractSlateFrame",
+                    "label": "ExtractSlateFrame",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "viewer_lut_raw",
+                            "label": "Viewer LUT raw"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "NukeSubmitDeadline",
+                    "label": "NukeSubmitDeadline",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "number",
+                            "key": "deadline_priority",
+                            "label": "deadline_priority"
+                        },
+                        {
+                            "type": "text",
+                            "key": "deadline_pool",
+                            "label": "deadline_pool"
+                        },
+                        {
+                            "type": "text",
+                            "key": "deadline_pool_secondary",
+                            "label": "deadline_pool_secondary"
+                        },
+                        {
+                            "type": "number",
+                            "key": "deadline_chunk_size",
+                            "label": "deadline_chunk_size"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "schema",
+            "name": "schema_workfile_build"
+        },
+        {
+            "type": "schema",
+            "name": "schema_publish_gui_filter"
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_resolve.json

@@ -0,0 +1,124 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "resolve",
+    "label": "DaVinci Resolve",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "create",
+            "label": "Creator plugins",
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "CreateShotClip",
+                    "label": "Create Shot Clip",
+                    "is_group": true,
+                    "children": [
+                        {
+                          "type": "collapsible-wrap",
+                          "label": "Shot Hierarchy And Rename Settings",
+                          "collapsable": false,
+                          "children": [
+                            {
+                                "type": "text",
+                                "key": "hierarchy",
+                                "label": "Shot parent hierarchy"
+                            },
+                            {
+                                "type": "boolean",
+                                "key": "clipRename",
+                                "label": "Rename clips"
+                            },
+                            {
+                                "type": "text",
+                                "key": "clipName",
+                                "label": "Clip name template"
+                            },
+                            {
+                                "type": "number",
+                                "key": "countFrom",
+                                "label": "Count sequence from"
+                            },
+                            {
+                                "type": "number",
+                                "key": "countSteps",
+                                "label": "Stepping number"
+                            }
+                          ]
+                        },
+                        {
+                          "type": "collapsible-wrap",
+                          "label": "Shot Template Keywords",
+                          "collapsable": false,
+                          "children": [
+                            {
+                                "type": "text",
+                                "key": "folder",
+                                "label": "{folder}"
+                            },
+                            {
+                                "type": "text",
+                                "key": "episode",
+                                "label": "{episode}"
+                            },
+                            {
+                                "type": "text",
+                                "key": "sequence",
+                                "label": "{sequence}"
+                            },
+                            {
+                                "type": "text",
+                                "key": "track",
+                                "label": "{track}"
+                            },
+                            {
+                                "type": "text",
+                                "key": "shot",
+                                "label": "{shot}"
+                            }
+                          ]
+                        },
+                        {
+                          "type": "collapsible-wrap",
+                          "label": "Vertical Synchronization Of Attributes",
+                          "collapsable": false,
+                          "children": [
+                            {
+                                "type": "boolean",
+                                "key": "vSyncOn",
+                                "label": "Enable Vertical Sync"
+                            }
+                          ]
+                        },
+                        {
+                          "type": "collapsible-wrap",
+                          "label": "Shot Attributes",
+                          "collapsable": false,
+                          "children": [
+                            {
+                                "type": "number",
+                                "key": "workfileFrameStart",
+                                "label": "Workfiles Start Frame"
+                            },
+                            {
+                                "type": "number",
+                                "key": "handleStart",
+                                "label": "Handle start (head)"
+                            },
+                            {
+                                "type": "number",
+                                "key": "handleEnd",
+                                "label": "Handle end (tail)"
+                            }
+                          ]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_standalonepublisher.json

@@ -0,0 +1,93 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "standalonepublisher",
+    "label": "Standalone Publisher",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "publish",
+            "label": "Publish plugins",
+            "is_file": true,
+            "children": [
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "ExtractThumbnailSP",
+                    "label": "ExtractThumbnailSP",
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "dict",
+                            "collapsable": false,
+                            "key": "ffmpeg_args",
+                            "label": "ffmpeg_args",
+                            "children": [
+                                {
+                                    "type": "list",
+                                    "object_type": "text",
+                                    "key": "input",
+                                    "label": "input"
+                                },
+                                {
+                                    "type": "list",
+                                    "object_type": "text",
+                                    "key": "output",
+                                    "label": "output"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "dict-modifiable",
+            "collapsable": true,
+            "key": "create",
+            "label": "Creator plugins",
+            "collapsable_key": true,
+            "is_file": true,
+            "object_type": {
+                "type": "dict",
+                "children": [
+                    {
+                        "type": "text",
+                        "key": "name",
+                        "label": "Name"
+                    },
+                    {
+                        "type": "text",
+                        "key": "label",
+                        "label": "Label"
+                    },
+                    {
+                        "type": "text",
+                        "key": "family",
+                        "label": "Family"
+                    },
+                    {
+                        "type": "text",
+                        "key": "icon",
+                        "label": "Icon"
+                    },
+                    {
+                        "type": "list",
+                        "key": "defaults",
+                        "label": "Defaults",
+                        "object_type": {
+                            "type": "text"
+                        }
+                    },
+                    {
+                        "type": "text",
+                        "key": "help",
+                        "label": "Help"
+                    }
+                ]
+            }
+        }
+    ]
+}

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

@@ -0,0 +1,76 @@
+{
+    "type": "dict",
+    "key": "sync_server",
+    "label": "Sync Server (currently unused)",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "is_file": true,
+    "children": [
+    {
+        "type": "boolean",
+        "key": "enabled",
+        "label": "Enabled"
+    },
+    {
+        "type": "dict",
+        "key": "config",
+        "label": "Config",
+        "collapsable": true,
+        "children": [
+
+            {
+                "type": "text",
+                "key": "local_id",
+                "label": "Local ID"
+            },
+            {
+                "type": "text",
+                "key": "retry_cnt",
+                "label": "Retry Count"
+            },
+            {
+                "type": "text",
+                "key": "loop_delay",
+                "label": "Loop Delay"
+            },
+            {
+                "type": "text",
+                "key": "active_site",
+                "label": "Active Site"
+            },
+            {
+                "type": "text",
+                "key": "remote_site",
+                "label": "Remote Site"
+            }
+        ]
+    }, {
+        "type": "dict-modifiable",
+        "collapsable": true,
+        "key": "sites",
+        "label": "Sites",
+        "collapsable_key": false,
+        "is_file": true,
+        "object_type":
+        {
+            "type": "dict",
+            "children": [
+            {
+                "type": "text",
+                "key": "provider",
+                "label": "Provider"
+            },
+            {
+                "type": "text",
+                "key": "credentials_url",
+                "label": "Credentials url"
+            },
+            {
+                "type": "text",
+                "key": "root",
+                "label": "Root"
+            }]
+        }
+    }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schema_project_unreal.json

@@ -0,0 +1,27 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "unreal",
+    "label": "Unreal Engine",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "project_setup",
+            "label": "Project Setup",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "dev_mode",
+                    "label": "Dev mode"
+                },
+                {
+                    "type": "boolean",
+                    "key": "install_unreal_python_engine",
+                    "label": "Install unreal python engine"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_anatomy_attributes.json

@@ -0,0 +1,79 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "attributes",
+    "label": "Attributes",
+    "is_file": true,
+    "children": [
+        {
+            "type": "number",
+            "key": "fps",
+            "label": "Frame Rate"
+        },
+        {
+            "type": "number",
+            "key": "frameStart",
+            "label": "Frame Start"
+        },
+        {
+            "type": "number",
+            "key": "frameEnd",
+            "label": "Frame End"
+        },
+        {
+            "type": "number",
+            "key": "clipIn",
+            "label": "Clip In"
+        },
+        {
+            "type": "number",
+            "key": "clipOut",
+            "label": "Clip Out"
+        },
+        {
+            "type": "number",
+            "key": "handleStart",
+            "label": "Handle Start"
+        },
+        {
+            "type": "number",
+            "key": "handleEnd",
+            "label": "Handle End"
+        },
+        {
+            "type": "number",
+            "key": "resolutionWidth",
+            "label": "Resolution Width"
+        },
+        {
+            "type": "number",
+            "key": "resolutionHeight",
+            "label": "Resolution Height"
+        },
+        {
+            "type": "number",
+            "key": "pixelAspect",
+            "label": "Pixel Aspect Ratio"
+        },
+        {
+            "type": "enum",
+            "key": "applications",
+            "label": "Applications",
+            "multiselection": true,
+            "enum_items": [
+                { "maya_2020": "Maya 2020" },
+                { "nuke_12.2": "Nuke 12.2" },
+                { "hiero_12.2": "Hiero 12.2" },
+                { "houdini_18": "Houdini 18" },
+                { "blender_2.91": "Blender 2.91" },
+                { "aftereffects_2021": "After Effects 2021" }
+            ]
+        },
+        {
+            "type": "dict-modifiable",
+            "key": "task_short_names",
+            "label": "Task short names (by Task type)",
+            "object_type": "text"
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_anatomy_imageio.json

@@ -0,0 +1,353 @@
+{
+    "type": "dict",
+    "key": "imageio",
+    "label": "Color Management and Output Formats",
+    "is_file": true,
+    "children": [
+        {
+            "key": "hiero",
+            "type": "dict",
+            "label": "Hiero",
+            "children": [
+                {
+                    "key": "workfile",
+                    "type": "dict",
+                    "label": "Workfile",
+                    "collapsable": false,
+                    "children": [
+                        {
+                            "type": "form",
+                            "children": [
+                                {
+                                    "type": "enum",
+                                    "key": "ocioConfigName",
+                                    "label": "OpenColorIO Config",
+                                    "enum_items": [
+                                        {
+                                            "nuke-default": "nuke-default"
+                                        },
+                                        {
+                                            "aces_1.0.3": "aces_1.0.3"
+                                        },
+                                        {
+                                            "aces_1.1": "aces_1.1"
+                                        },
+                                        {
+                                            "custom": "custom"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "type": "path-widget",
+                                    "key": "ocioconfigpath",
+                                    "label": "Custom OCIO path",
+                                    "multiplatform": true,
+                                    "multipath": true
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "workingSpace",
+                                    "label": "Working Space"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "sixteenBitLut",
+                                    "label": "16 Bit Files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "eightBitLut",
+                                    "label": "8 Bit Files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "floatLut",
+                                    "label": "Floating Point Files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "logLut",
+                                    "label": "Log Files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "viewerLut",
+                                    "label": "Viewer"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "thumbnailLut",
+                                    "label": "Thumbnails"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "key": "regexInputs",
+                    "type": "dict",
+                    "label": "Colorspace on Inputs by regex detection",
+                    "collapsable": true,
+                    "children": [
+                        {
+                            "type": "list",
+                            "key": "inputs",
+                            "object_type": {
+                                "type": "dict",
+                                "children": [
+                                    {
+                                        "type": "text",
+                                        "key": "regex",
+                                        "label": "Regex"
+                                    },
+                                    {
+                                        "type": "text",
+                                        "key": "colorspace",
+                                        "label": "Colorspace"
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "key": "nuke",
+            "type": "dict",
+            "label": "Nuke",
+            "children": [
+                {
+                    "key": "workfile",
+                    "type": "dict",
+                    "label": "Workfile",
+                    "collapsable": false,
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "form",
+                            "children": [
+                                {
+                                    "type": "enum",
+                                    "key": "colorManagement",
+                                    "label": "color management",
+                                    "enum_items": [
+                                        {
+                                            "Nuke": "Nuke"
+                                        },
+                                        {
+                                            "OCIO": "OCIO"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "type": "enum",
+                                    "key": "OCIO_config",
+                                    "label": "OpenColorIO Config",
+                                    "enum_items": [
+                                        {
+                                            "nuke-default": "nuke-default"
+                                        },
+                                        {
+                                            "spi-vfx": "spi-vfx"
+                                        },
+                                        {
+                                            "spi-anim": "spi-anim"
+                                        },
+                                        {
+                                            "aces_1.0.3": "aces_0.1.1"
+                                        },
+                                        {
+                                            "aces_1.0.3": "aces_0.7.1"
+                                        },
+                                        {
+                                            "aces_1.0.3": "aces_1.0.1"
+                                        },
+                                        {
+                                            "aces_1.0.3": "aces_1.0.3"
+                                        },
+                                        {
+                                            "aces_1.1": "aces_1.1"
+                                        },
+                                        {
+                                            "custom": "custom"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "type": "path-widget",
+                                    "key": "customOCIOConfigPath",
+                                    "label": "Custom OCIO config path",
+                                    "multiplatform": true,
+                                    "multipath": true
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "workingSpaceLUT",
+                                    "label": "Working Space"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "monitorLut",
+                                    "label": "monitor"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "int8Lut",
+                                    "label": "8-bit files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "int16Lut",
+                                    "label": "16-bit files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "logLut",
+                                    "label": "log files"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "floatLut",
+                                    "label": "float files"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "key": "nodes",
+                    "type": "dict",
+                    "label": "Nodes",
+                    "collapsable": true,
+                    "is_group": true,
+                    "children": [
+                        {
+                            "key": "requiredNodes",
+                            "type": "list",
+                            "label": "Required Nodes",
+                            "object_type": {
+                                "type": "dict",
+                                "children": [
+                                    {
+                                        "type": "list",
+                                        "key": "plugins",
+                                        "label": "Used in plugins",
+                                        "object_type": {
+                                            "type": "text",
+                                            "key": "pluginClass",
+                                            "label": "Plugin Class"
+                                        }
+                                    },
+                                    {
+                                        "type": "text",
+                                        "key": "nukeNodeClass",
+                                        "label": "Nuke Node Class"
+                                    },
+                                    {
+                                        "type": "splitter"
+                                    },
+                                    {
+                                        "key": "knobs",
+                                        "label": "Knobs",
+                                        "type": "list",
+                                        "object_type": {
+                                            "type": "dict",
+                                            "children": [
+                                                {
+                                                    "type": "text",
+                                                    "key": "name",
+                                                    "label": "Name"
+                                                },
+                                                {
+                                                    "type": "text",
+                                                    "key": "value",
+                                                    "label": "Value"
+                                                }
+                                            ]
+                                        }
+                                    }
+                                ]
+                            }
+                        },
+                        {
+                            "type": "list",
+                            "key": "customNodes",
+                            "label": "Custom Nodes",
+                            "object_type": {
+                                "type": "dict",
+                                "children": [
+                                    {
+                                        "type": "list",
+                                        "key": "plugins",
+                                        "label": "Used in plugins",
+                                        "object_type": {
+                                            "type": "text",
+                                            "key": "pluginClass",
+                                            "label": "Plugin Class"
+                                        }
+                                    },
+                                    {
+                                        "type": "text",
+                                        "key": "nukeNodeClass",
+                                        "label": "Nuke Node Class"
+                                    },
+                                    {
+                                        "type": "splitter"
+                                    },
+                                    {
+                                        "key": "knobs",
+                                        "label": "Knobs",
+                                        "type": "list",
+                                        "object_type": {
+                                            "type": "dict",
+                                            "children": [
+                                                {
+                                                    "type": "text",
+                                                    "key": "name",
+                                                    "label": "Name"
+                                                },
+                                                {
+                                                    "type": "text",
+                                                    "key": "value",
+                                                    "label": "Value"
+                                                }
+                                            ]
+                                        }
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                },
+                {
+                    "key": "regexInputs",
+                    "type": "dict",
+                    "label": "Colorspace on Inputs by regex detection",
+                    "collapsable": true,
+                    "children": [
+                        {
+                            "type": "list",
+                            "key": "inputs",
+                            "object_type": {
+                                "type": "dict",
+                                "children": [
+                                    {
+                                        "type": "text",
+                                        "key": "regex",
+                                        "label": "Regex"
+                                    },
+                                    {
+                                        "type": "text",
+                                        "key": "colorspace",
+                                        "label": "Colorspace"
+                                    }
+                                ]
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_anatomy_templates.json

@@ -0,0 +1,135 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "templates",
+    "label": "Templates",
+    "collapsable_key": true,
+    "is_file": true,
+    "children": [
+        {
+            "type": "number",
+            "key": "version_padding",
+            "label": "Version Padding"
+        },
+        {
+            "type": "text",
+            "key": "version",
+            "label": "Version"
+        },
+        {
+            "type": "number",
+            "key": "frame_padding",
+            "label": "Frame Padding"
+        },
+        {
+            "type": "text",
+            "key": "frame",
+            "label": "Frame"
+        },
+        {
+            "type": "dict",
+            "key": "work",
+            "label": "Work",
+            "children": [
+                {
+                    "type": "text",
+                    "key": "folder",
+                    "label": "Folder"
+                },
+                {
+                    "type": "text",
+                    "key": "file",
+                    "label": "File"
+                },
+                {
+                    "type": "text",
+                    "key": "path",
+                    "label": "Path"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "render",
+            "label": "Render",
+            "children": [
+                {
+                    "type": "text",
+                    "key": "folder",
+                    "label": "Folder"
+                },
+                {
+                    "type": "text",
+                    "key": "file",
+                    "label": "File"
+                },
+                {
+                    "type": "text",
+                    "key": "path",
+                    "label": "Path"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "publish",
+            "label": "Publish",
+            "children": [
+                {
+                    "type": "text",
+                    "key": "folder",
+                    "label": "Folder"
+                },
+                {
+                    "type": "text",
+                    "key": "file",
+                    "label": "File"
+                },
+                {
+                    "type": "text",
+                    "key": "path",
+                    "label": "Path"
+                },
+                {
+                    "type": "text",
+                    "key": "thumbnail",
+                    "label": "Thumbnail"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "master",
+            "label": "Master",
+            "children": [
+                {
+                    "type": "text",
+                    "key": "folder",
+                    "label": "Folder"
+                },
+                {
+                    "type": "text",
+                    "key": "file",
+                    "label": "File"
+                },
+                {
+                    "type": "text",
+                    "key": "path",
+                    "label": "Path"
+                }
+            ]
+        },
+        {
+            "type": "dict-modifiable",
+            "key": "delivery",
+            "label": "Delivery",
+            "object_type": "text"
+        },
+        {
+            "type": "dict-modifiable",
+            "key": "other",
+            "label": "Other",
+            "object_type": "text"
+        }
+    ]
+}

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

@@ -0,0 +1,407 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "publish",
+    "label": "Publish plugins",
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "key": "IntegrateMasterVersion",
+            "label": "IntegrateMasterVersion",
+            "is_group": true,
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "key": "ExtractJpegEXR",
+            "label": "ExtractJpegEXR",
+            "is_group": true,
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "dict",
+                    "key": "ffmpeg_args",
+                    "children": [
+                        {
+                            "type": "list",
+                            "object_type": "text",
+                            "key": "input",
+                            "label": "FFmpeg input arguments"
+                        },
+                        {
+                            "type": "list",
+                            "object_type": "text",
+                            "key": "output",
+                            "label": "FFmpeg output arguments"
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ExtractReview",
+            "label": "ExtractReview",
+            "checkbox_key": "enabled",
+            "is_group": true,
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "list",
+                    "key": "profiles",
+                    "label": "Profiles",
+                    "object_type": {
+                        "type": "dict",
+                        "children": [
+                            {
+                                "key": "families",
+                                "label": "Families",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "key": "hosts",
+                                "label": "Hosts",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "type": "splitter"
+                            },
+                            {
+                                "key": "outputs",
+                                "label": "Output Definitions",
+                                "type": "dict-modifiable",
+                                "highlight_content": true,
+                                "object_type": {
+                                    "type": "dict",
+                                    "children": [
+                                        {
+                                            "key": "ext",
+                                            "label": "Output extension",
+                                            "type": "text"
+                                        },
+                                        {
+                                            "key": "tags",
+                                            "label": "Tags",
+                                            "type": "enum",
+                                            "multiselection": true,
+                                            "enum_items": [
+                                                {
+                                                    "burnin": "Add burnins"
+                                                },
+                                                {
+                                                    "ftrackreview": "Add to Ftrack"
+                                                },
+                                                {
+                                                    "delete": "Delete output"
+                                                },
+                                                {
+                                                    "slate-frame": "Add slate frame"
+                                                },
+                                                {
+                                                    "no-hnadles": "Skip handle frames"
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "key": "ffmpeg_args",
+                                            "label": "FFmpeg arguments",
+                                            "type": "dict",
+                                            "highlight_content": true,
+                                            "children": [
+                                                {
+                                                    "key": "video_filters",
+                                                    "label": "Video filters",
+                                                    "type": "list",
+                                                    "object_type": "text"
+                                                },
+                                                {
+                                                    "type": "splitter"
+                                                },
+                                                {
+                                                    "key": "audio_filters",
+                                                    "label": "Audio filters",
+                                                    "type": "list",
+                                                    "object_type": "text"
+                                                },
+                                                {
+                                                    "type": "splitter"
+                                                },
+                                                {
+                                                    "key": "input",
+                                                    "label": "Input arguments",
+                                                    "type": "list",
+                                                    "object_type": "text"
+                                                },
+                                                {
+                                                    "type": "splitter"
+                                                },
+                                                {
+                                                    "key": "output",
+                                                    "label": "Output arguments",
+                                                    "type": "list",
+                                                    "object_type": "text"
+                                                }
+                                            ]
+                                        },
+                                        {
+                                            "key": "filter",
+                                            "label": "Additional output filtering",
+                                            "type": "dict",
+                                            "highlight_content": true,
+                                            "children": [
+                                                {
+                                                    "key": "families",
+                                                    "label": "Families",
+                                                    "type": "list",
+                                                    "object_type": "text"
+                                                }
+                                            ]
+                                        }
+                                    ]
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ExtractBurnin",
+            "label": "ExtractBurnin",
+            "checkbox_key": "enabled",
+            "is_group": true,
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "options",
+                    "label": "Burnin formating options",
+                    "children": [
+                        {
+                            "type": "number",
+                            "key": "font_size",
+                            "label": "Font size"
+                        },
+                        {
+                            "type": "number",
+                            "key": "opacity",
+                            "label": "Font opacity"
+                        },
+                        {
+                            "type": "number",
+                            "key": "bg_opacity",
+                            "label": "Background opacity"
+                        },
+                        {
+                            "type": "number",
+                            "key": "x_offset",
+                            "label": "X Offset"
+                        },
+                        {
+                            "type": "number",
+                            "key": "y_offset",
+                            "label": "Y Offset"
+                        },
+                        {
+                            "type": "number",
+                            "key": "bg_padding",
+                            "label": "Padding aroung text"
+                        },
+                        {
+                            "type": "splitter"
+                        }
+                    ]
+                },
+
+                {
+                    "type": "list",
+                    "key": "profiles",
+                    "label": "Profiles",
+                    "object_type": {
+                        "type": "dict",
+                        "children": [
+                            {
+                                "key": "families",
+                                "label": "Families",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "key": "hosts",
+                                "label": "Hosts",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "type": "splitter"
+                            },
+                            {
+                                "key": "burnins",
+                                "label": "Burnins",
+                                "type": "dict-modifiable",
+                                "highlight_content": true,
+                                "collapsable": false,
+                                "object_type": {
+                                    "type": "dict",
+                                    "children": [
+                                        {
+                                            "key": "TOP_LEFT",
+                                            "label": "Top Left",
+                                            "type": "text"
+                                        },
+                                        {
+                                            "key": "TOP_CENTERED",
+                                            "label": "Top Centered",
+                                            "type": "text"
+                                        },
+                                        {
+                                            "key": "TOP_RIGHT",
+                                            "label": "top Right",
+                                            "type": "text"
+                                        },
+                                        {
+                                            "key": "BOTTOM_LEFT",
+                                            "label": "Bottom Left",
+                                            "type": "text"
+                                        },
+                                        {
+                                            "key": "BOTTOM_CENTERED",
+                                            "label": "Bottom Centered",
+                                            "type": "text"
+                                        },
+                                        {
+                                            "key": "BOTTOM_RIGHT",
+                                            "label": "BottomRight",
+                                            "type": "text"
+                                        }
+                                    ]
+                                }
+                            }
+                        ]
+                    }
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "IntegrateAssetNew",
+            "label": "IntegrateAssetNew",
+            "is_group": true,
+            "children": [
+                {
+                    "type": "raw-json",
+                    "key": "template_name_profiles",
+                    "label": "template_name_profiles"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ProcessSubmittedJobOnFarm",
+            "label": "ProcessSubmittedJobOnFarm",
+            "checkbox_key": "enabled",
+            "is_group": true,
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "text",
+                    "key": "deadline_department",
+                    "label": "Deadline department"
+                },
+                {
+                    "type": "text",
+                    "key": "deadline_pool",
+                    "label": "Deadline Pool"
+                },
+                {
+                    "type": "text",
+                    "key": "deadline_group",
+                    "label": "Deadline Group"
+                },
+                {
+                    "type": "number",
+                    "key": "deadline_chunk_size",
+                    "label": "Deadline Chunk Size"
+                },
+                {
+                    "type": "number",
+                    "key": "deadline_priority",
+                    "label": "Deadline Priotity"
+                },
+                {
+                    "type": "dict",
+                    "key": "aov_filter",
+                    "label": "Reviewable subsets filter",
+                    "children": [
+                        {
+                            "type": "list",
+                            "key": "maya",
+                            "label": "Maya",
+                            "object_type": {
+                                "type": "text"
+                            }
+                        },
+                        {
+                            "type": "list",
+                            "key": "nuke",
+                            "label": "Nuke",
+                            "object_type": {
+                                "type": "text"
+                            }
+                        },
+                        {
+                            "type": "list",
+                            "key": "aftereffects",
+                            "label": "After Effects",
+                            "object_type": {
+                                "type": "text"
+                            }
+                        },
+                        {
+                            "type": "list",
+                            "key": "celaction",
+                            "label": "Celaction",
+                            "object_type": {
+                                "type": "text"
+                            }
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_global_tools.json

@@ -0,0 +1,77 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "tools",
+    "label": "Tools",
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "creator",
+            "label": "Creator",
+            "children": [
+                {
+                    "type": "dict-modifiable",
+                    "collapsable": false,
+                    "key": "families_smart_select",
+                    "label": "Families smart select",
+                    "object_type": {
+                        "type": "list",
+                        "object_type": "text"
+                    }
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "Workfiles",
+            "label": "Workfiles",
+            "children": [
+                {
+                    "type": "list",
+                    "key": "last_workfile_on_startup",
+                    "label": "Open last workfiles on launch",
+                    "is_group": true,
+                    "use_label_wrap": true,
+                    "object_type": {
+                        "type": "dict",
+                        "children": [
+                            {
+                                "key": "hosts",
+                                "label": "Hosts",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "key": "tasks",
+                                "label": "Tasks",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "type": "splitter"
+                            },
+                            {
+                                "type": "boolean",
+                                "key": "enabled",
+                                "label": "Enabled"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "dict-modifiable",
+                    "collapsable": true,
+                    "key": "sw_folders",
+                    "label": "Extra task folders",
+                    "is_group": true,
+                    "object_type": {
+                        "type": "list",
+                        "object_type": "text"
+                    }
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_maya_capture.json

@@ -0,0 +1,595 @@
+{
+    "type": "collapsible-wrap",
+    "label": "Collapsible Wrapper without key",
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "capture",
+            "label": "Maya Playblast settings",
+            "is_file": true,
+            "children": [
+                {
+                    "type": "dict",
+                    "key": "Codec",
+                    "children": [
+                        {
+                            "type": "label",
+                            "label": "<b>Codec</b>"
+                        },
+                        {
+                            "type": "text",
+                            "key": "compression",
+                            "label": "Compression type"
+                        },
+                        {
+                            "type": "text",
+                            "key": "format",
+                            "label": "Data format"
+                        },
+                        {
+                            "type": "number",
+                            "key": "quality",
+                            "label": "Quality",
+                            "decimal": 0,
+                            "minimum": 0,
+                            "maximum": 100
+                        },
+
+                        {
+                            "type": "splitter"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "Display Options",
+                    "children": [
+                        {
+                            "type": "label",
+                            "label": "<b>Display Options</b>"
+                        },
+                        {
+                            "type": "list-strict",
+                            "key": "background",
+                            "label": "Background Color:    ",
+                            "object_types": [
+                                {
+                                    "label": "Red",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                },
+                                {
+                                    "label": "Green",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                },
+                                {
+                                    "label": "Blue",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                }
+                            ]
+                        },
+                        {
+                            "type": "list-strict",
+                            "key": "backgroundBottom",
+                            "label": "Background Bottom:    ",
+                            "object_types": [
+                                {
+                                    "label": "Red",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                },
+                                {
+                                    "label": "Green",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                },
+                                {
+                                    "label": "Blue",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                }
+                            ]
+                        },
+                        {
+                            "type": "list-strict",
+                            "key": "backgroundTop",
+                            "label": "Background Top:    ",
+                            "object_types": [
+                                {
+                                    "label": "Red",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                },
+                                {
+                                    "label": "Green",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                },
+                                {
+                                    "label": "Blue",
+                                    "type": "number",
+                                    "minimum": 0,
+                                    "maximum": 1,
+                                    "decimal": 3
+                                }
+                            ]
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "override_display",
+                            "label": "Override display options"
+                        }
+                    ]
+                },
+                {
+                    "type": "splitter"
+                },
+                {
+                    "type": "dict",
+                    "key": "Generic",
+                    "children": [
+                        {
+                            "type": "label",
+                            "label": "<b>Generic</b>"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "isolate_view",
+                            "label": "            Isolate view"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "off_screen",
+                            "label": "            Off Screen"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "IO",
+                    "children": [
+                        {
+                            "type": "label",
+                            "label": "<b>IO</b>"
+                        },
+                        {
+                            "type": "text",
+                            "key": "name",
+                            "label": "Name"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "open_finished",
+                            "label": "Open finished"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "raw_frame_numbers",
+                            "label": "Raw frame numbers"
+                        },
+                        {
+                            "type": "list",
+                            "key": "recent_playblasts",
+                            "label": "Recent Playblasts",
+                            "object_type": "text"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "save_file",
+                            "label": "Save file"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "PanZoom",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "pan_zoom",
+                            "label": "              Pan Zoom"
+                        }
+                    ]
+                },
+                {
+                    "type": "splitter"
+                },
+                {
+                    "type": "dict",
+                    "key": "Renderer",
+                    "children": [
+                        {
+                            "type": "label",
+                            "label": "<b>Renderer</b>"
+                        },
+                        {
+                            "type": "text",
+                            "key": "rendererName",
+                            "label": "     Renderer name"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "Resolution",
+                    "children": [
+                        {
+                            "type": "splitter"
+                        },
+                        {
+                            "type": "label",
+                            "label": "<b>Resolution</b>"
+                        },
+                        {
+                            "type": "number",
+                            "key": "width",
+                            "label": "                  Width",
+                            "decimal": 0,
+                            "minimum": 0,
+                            "maximum": 99999
+                        },
+                        {
+                            "type": "number",
+                            "key": "height",
+                            "label": "Height",
+                            "decimal": 0,
+                            "minimum": 0,
+                            "maximum": 99999
+                        },
+                        {
+                            "type": "number",
+                            "key": "percent",
+                            "label": "percent",
+                            "decimal": 1,
+                            "minimum": 0,
+                            "maximum": 200
+                        },
+                        {
+                            "type": "text",
+                            "key": "mode",
+                            "label": "Mode"
+                        }
+                    ]
+                },
+                {
+                    "type": "splitter"
+                },
+                {
+                    "type": "dict",
+                    "key": "Time Range",
+                    "children": [
+                        {
+                            "type": "label",
+                            "label": "<b>Time Range</b>"
+                        },
+                        {
+                            "type": "number",
+                            "key": "start_frame",
+                            "label": "            Start frame",
+                            "decimal": 0,
+                            "minimum": 0,
+                            "maximum": 999999
+                        },
+                        {
+                            "type": "number",
+                            "key": "end_frame",
+                            "label": "End frame",
+                            "decimal": 0,
+                            "minimum": 0,
+                            "maximum": 999999
+                        },
+                        {
+                            "type": "text",
+                            "key": "frame",
+                            "label": "Frame"
+                        },
+                        {
+                            "type": "text",
+                            "key": "time",
+                            "label": "Time"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "Viewport Options",
+                    "label": "Viewport Options",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "cameras",
+                            "label": "cameras"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "clipGhosts",
+                            "label": "clipGhosts"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "controlVertices",
+                            "label": "controlVertices"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "deformers",
+                            "label": "deformers"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "dimensions",
+                            "label": "dimensions"
+                        },
+                        {
+                            "type": "number",
+                            "key": "displayLights",
+                            "label": "displayLights",
+                            "decimal": 0,
+                            "minimum": 0,
+                            "maximum": 10
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "dynamicConstraints",
+                            "label": "dynamicConstraints"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "dynamics",
+                            "label": "dynamics"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "fluids",
+                            "label": "fluids"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "follicles",
+                            "label": "follicles"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "gpuCacheDisplayFilter",
+                            "label": "gpuCacheDisplayFilter"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "greasePencils",
+                            "label": "greasePencils"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "grid",
+                            "label": "grid"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "hairSystems",
+                            "label": "hairSystems"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "handles",
+                            "label": "handles"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "high_quality",
+                            "label": "high_quality"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "hud",
+                            "label": "hud"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "hulls",
+                            "label": "hulls"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "ikHandles",
+                            "label": "ikHandles"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "imagePlane",
+                            "label": "imagePlane"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "joints",
+                            "label": "joints"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "lights",
+                            "label": "lights"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "locators",
+                            "label": "locators"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "manipulators",
+                            "label": "manipulators"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "motionTrails",
+                            "label": "motionTrails"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "nCloths",
+                            "label": "nCloths"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "nParticles",
+                            "label": "nParticles"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "nRigids",
+                            "label": "nRigids"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "nurbsCurves",
+                            "label": "nurbsCurves"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "nurbsSurfaces",
+                            "label": "nurbsSurfaces"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "override_viewport_options",
+                            "label": "override_viewport_options"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "particleInstancers",
+                            "label": "particleInstancers"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "pivots",
+                            "label": "pivots"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "planes",
+                            "label": "planes"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "pluginShapes",
+                            "label": "pluginShapes"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "polymeshes",
+                            "label": "polymeshes"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "shadows",
+                            "label": "shadows"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "strokes",
+                            "label": "strokes"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "subdivSurfaces",
+                            "label": "subdivSurfaces"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "textures",
+                            "label": "textures"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "twoSidedLighting",
+                            "label": "twoSidedLighting"
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "collapsable": true,
+                    "key": "Camera Options",
+                    "label": "Camera Options",
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "displayGateMask",
+                            "label": "displayGateMask"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displayResolution",
+                            "label": "displayResolution"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displayFilmGate",
+                            "label": "displayFilmGate"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displayFieldChart",
+                            "label": "displayFieldChart"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displaySafeAction",
+                            "label": "displaySafeAction"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displaySafeTitle",
+                            "label": "displaySafeTitle"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displayFilmPivot",
+                            "label": "displayFilmPivot"
+                        },
+                        {
+                            "type": "boolean",
+                            "key": "displayFilmOrigin",
+                            "label": "displayFilmOrigin"
+                        },
+                        {
+                            "type": "number",
+                            "key": "overscan",
+                            "label": "overscan",
+                            "decimal": 1,
+                            "minimum": 0,
+                            "maximum": 10
+                        }
+                    ]
+                }
+            ]
+        },
+        {
+            "type": "dict-modifiable",
+            "key": "ext_mapping",
+            "label": "Extension Mapping",
+            "object_type": {
+                "type": "text"
+            }
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_maya_load.json

@@ -0,0 +1,156 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "load",
+    "label": "Loader plugins",
+    "children": [
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "colors",
+            "label": "Loaded Subsets Outliner Colors",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Model",
+                            "name": "model"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Rig",
+                            "name": "rig"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Pointcache",
+                            "name": "pointcache"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Animation",
+                            "name": "animation"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Arnold Standin",
+                            "name": "ass"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Camera",
+                            "name": "camera"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "FBX",
+                            "name": "fbx"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Maya Scene",
+                            "name": "mayaAscii"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Set Dress",
+                            "name": "setdress"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Layout",
+                            "name": "layout"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "VDB Cache",
+                            "name": "vdbcache"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Vray Proxy",
+                            "name": "vrayproxy"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Yeti Cache",
+                            "name": "yeticache"
+                        }
+                    ]
+                },
+                {
+                    "type": "schema_template",
+                    "name": "template_color",
+                    "template_data": [
+                        {
+                            "label": "Yeti Rig",
+                            "name": "yetiRig"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

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

@@ -0,0 +1,214 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "publish",
+    "label": "Publish plugins",
+    "children": [
+        {
+            "type": "label",
+            "label": "Collectors"
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "CollectMayaRender",
+            "label": "Collect Render Layers",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "sync_workfile_version",
+                    "label": "Sync render version with workfile"
+                }
+            ]
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "type": "label",
+            "label": "Collectors"
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ValidateCameraAttributes",
+            "label": "Validate Camera Attributes",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "boolean",
+                    "key": "optional",
+                    "label": "Optional"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ValidateModelName",
+            "label": "Validate Model Name",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "label",
+                    "label": "Path to material file defining list of material names to check. This is material name per line simple text file.<br/>It will be checked against named group <b>shader</b> in your <em>Validation regex</em>.<p>For example: <br/> <code>^.*(?P=&lt;shader&gt;.+)_GEO</code></p>"
+                },
+                {
+                    "type": "path-widget",
+                    "key": "material_file",
+                    "label": "Material File",
+                    "multiplatform": true,
+                    "multipath": false
+                },
+                {
+                    "type": "text",
+                    "key": "regex",
+                    "label": "Validation regex"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ValidateAssemblyName",
+            "label": "Validate Assembly Name",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ValidateShaderName",
+            "label": "ValidateShaderName",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "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>"
+                },
+                {
+                    "type": "text",
+                    "key": "regex",
+                    "label": "Validation regex"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ValidateMeshHasOverlappingUVs",
+            "label": "ValidateMeshHasOverlappingUVs",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ValidateAttributes",
+            "label": "ValidateAttributes",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "raw-json",
+                    "key": "attributes",
+                    "label": "Attributes"
+                }
+            ]
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "type": "label",
+            "label": "Extractors"
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "ExtractCameraAlembic",
+            "label": "Extract camera to Alembic",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "label",
+                    "label": "List of attributes that will be added to the baked alembic camera. Needs to be written in python list syntax.<p>For example: <br/> <code>[\"attributeName\", \"anotherAttribute\"]</code></p>"
+                },
+                {
+                    "type": "boolean",
+                    "key": "optional",
+                    "label": "Optional"
+                },
+                {
+                    "type": "raw-json",
+                    "key": "bake_attributes",
+                    "label": "Bake Attributes"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "collapsable": true,
+            "key": "MayaSubmitDeadline",
+            "label": "Submit maya job to deadline",
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "enum",
+                    "key": "tile_assembler_plugin",
+                    "label": "Tile Assembler Plugin",
+                    "multiselection": false,
+                    "enum_items": [
+                        {
+                            "DraftTileAssembler": "Draft Tile Assembler"
+                        },
+                        {
+                            "oiio": "Open Image IO"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_publish_gui_filter.json

@@ -0,0 +1,10 @@
+{
+    "type": "dict-modifiable",
+    "collapsable": true,
+    "key": "filters",
+    "label": "Publish GUI Filters",
+    "object_type": {
+        "type": "raw-json",
+        "label": "Plugins"
+    }
+}

pype/settings/entities/schemas/projects_schema/schemas/schema_workfile_build.json

@@ -0,0 +1,97 @@
+{
+    "type": "dict",
+    "collapsable": true,
+    "key": "workfile_build",
+    "label": "Workfile Build Settings",
+    "children": [
+        {
+            "type": "list",
+            "key": "profiles",
+            "label": "Profiles",
+            "object_type": {
+                "type": "dict",
+                "children": [
+                    {
+                        "key": "tasks",
+                        "label": "Tasks",
+                        "type": "list",
+                        "object_type": "text"
+                    },
+                    {
+                        "type": "splitter"
+                    },
+                    {
+                        "key": "current_context",
+                        "label": "<b>Current Context</b>",
+                        "type": "list",
+                        "highlight_content": true,
+                        "object_type": {
+                            "type": "dict",
+                            "children": [
+                                {
+                                    "key": "subset_name_filters",
+                                    "label": "Subset name Filters",
+                                    "type": "list",
+                                    "object_type": "text"
+                                },
+                                {
+                                    "key": "families",
+                                    "label": "Families",
+                                    "type": "list",
+                                    "object_type": "text"
+                                },
+                                {
+                                    "key": "repre_names",
+                                    "label": "Repre Names",
+                                    "type": "list",
+                                    "object_type": "text"
+                                },
+                                {
+                                    "key": "loaders",
+                                    "label": "Loaders",
+                                    "type": "list",
+                                    "object_type": "text"
+                                }
+                            ]
+                        }
+                    },
+                    {
+                        "key": "linked_assets",
+                        "label": "<b>Linked Assets</b>",
+                        "type": "list",
+                        "highlight_content": true,
+                        "object_type": {
+                            "type": "dict",
+                            "children": [
+                                {
+                                    "key": "subset_name_filters",
+                                    "label": "Subset name Filters",
+                                    "type": "list",
+                                    "object_type": "text"
+                                },
+                                {
+                                    "key": "families",
+                                    "label": "Families",
+                                    "type": "list",
+                                    "object_type": "text"
+                                },
+                                {
+                                    "key": "repre_names",
+                                    "label": "Repre Names",
+                                    "type": "list",
+                                    "object_type": "text"
+                                },
+                                {
+                                    "key": "loaders",
+                                    "label": "Loaders",
+                                    "type": "list",
+                                    "object_type": "text"
+                                }
+                            ]
+                        }
+                    }
+                ]
+            }
+        }
+    ]
+}

pype/settings/entities/schemas/projects_schema/schemas/template_color.json

@@ -0,0 +1,30 @@
+[
+    {
+        "type": "list-strict",
+        "key": "{name}",
+        "label": "{label}:",
+        "object_types": [
+            {
+                "label": "Red",
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1,
+                "decimal": 3
+            },
+            {
+                "label": "Green",
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1,
+                "decimal": 3
+            },
+            {
+                "label": "Blue",
+                "type": "number",
+                "minimum": 0,
+                "maximum": 1,
+                "decimal": 3
+            }
+        ]
+    }
+]

pype/settings/entities/schemas/system_schema/example_schema.json

@@ -0,0 +1,485 @@
+{
+    "key": "example_dict",
+    "label": "Examples",
+    "type": "dict",
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "key": "schema_template_exaples",
+            "label": "Schema template examples",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "example_template",
+                    "template_data": {
+                        "host_label": "Application 1",
+                        "host_name": "app_1",
+                        "multipath_executables": false
+                    }
+                },
+                {
+                    "type": "schema_template",
+                    "name": "example_template",
+                    "template_data": {
+                        "host_label": "Application 2",
+                        "host_name": "app_2"
+                    }
+                }
+            ]
+        },
+        {
+            "key": "env_group_test",
+            "label": "EnvGroup Test",
+            "type": "dict",
+            "children": [
+                {
+                    "key": "key_to_store_in_system_settings",
+                    "label": "Testing environment group",
+                    "type": "raw-json",
+                    "env_group_key": "test_group"
+                }
+            ]
+        },
+        {
+            "key": "dict_wrapper",
+            "type": "dict",
+            "children": [
+                {
+                    "type": "enum",
+                    "key": "test_enum_singleselection",
+                    "label": "Enum Single Selection",
+                    "enum_items": [
+                        { "value_1": "Label 1" },
+                        { "value_2": "Label 2" },
+                        { "value_3": "Label 3" }
+                    ]
+                },
+                {
+                    "type": "enum",
+                    "key": "test_enum_multiselection",
+                    "label": "Enum Multi Selection",
+                    "multiselection": true,
+                    "enum_items": [
+                        { "value_1": "Label 1" },
+                        { "value_2": "Label 2" },
+                        { "value_3": "Label 3" }
+                    ]
+                },
+                {
+                    "type": "boolean",
+                    "key": "bool",
+                    "label": "Boolean checkbox"
+                },
+                {
+                    "type": "label",
+                    "label": "NOTE: This is label"
+                },
+                {
+                    "type": "splitter"
+                },
+                {
+                    "type": "number",
+                    "key": "integer",
+                    "label": "Integer",
+                    "decimal": 0,
+                    "minimum": 0,
+                    "maximum": 10
+                },
+                {
+                    "type": "number",
+                    "key": "float",
+                    "label": "Float (2 decimals)",
+                    "decimal": 2,
+                    "minimum": -10,
+                    "maximum": -5
+                },
+                {
+                    "type": "text",
+                    "key": "singleline_text",
+                    "label": "Singleline text"
+                },
+                {
+                    "type": "text",
+                    "key": "multiline_text",
+                    "label": "Multiline text",
+                    "multiline": true
+                },
+                {
+                    "type": "raw-json",
+                    "key": "raw_json",
+                    "label": "Raw json input"
+                },
+                {
+                    "type": "list",
+                    "key": "list_item_of_multiline_texts",
+                    "label": "List of multiline texts",
+                    "object_type": {
+                        "type": "text",
+                        "multiline": true
+                    }
+                },
+                {
+                    "type": "list",
+                    "key": "list_item_of_floats",
+                    "label": "List of floats",
+                    "object_type": {
+                        "type": "number",
+                        "decimal": 3,
+                        "minimum": 1000,
+                        "maximum": 2000
+                    }
+                },
+                {
+                    "type": "dict-modifiable",
+                    "key": "modifiable_dict_of_integers",
+                    "label": "Modifiable dict of integers",
+                    "object_type": {
+                        "type": "number",
+                        "decimal": 0,
+                        "minimum": 10,
+                        "maximum": 100
+                    }
+                },
+                {
+                    "type": "list-strict",
+                    "key": "strict_list_labels_horizontal",
+                    "label": "StrictList-labels-horizontal (color)",
+                    "object_types": [
+                        {
+                            "label": "Red",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "label": "Green",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "label": "Blue",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "label": "Alpha",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 1,
+                            "decimal": 6
+                        }
+                    ]
+                },
+                {
+                    "type": "list-strict",
+                    "key": "strict_list_labels_vertical",
+                    "label": "StrictList-labels-vertical (color)",
+                    "horizontal": false,
+                    "object_types": [
+                        {
+                            "label": "Red",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "label": "Green",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "label": "Blue",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "label": "Alpha",
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 1,
+                            "decimal": 6
+                        }
+                    ]
+                },
+                {
+                    "type": "list-strict",
+                    "key": "strict_list_nolabels_horizontal",
+                    "label": "StrictList-nolabels-horizontal (color)",
+                    "object_types": [
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 1,
+                            "decimal": 6
+                        }
+                    ]
+                },
+                {
+                    "type": "list-strict",
+                    "key": "strict_list_nolabels_vertical",
+                    "label": "StrictList-nolabels-vertical (color)",
+                    "horizontal": false,
+                    "object_types": [
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 255,
+                            "decimal": 0
+                        },
+                        {
+                            "type": "number",
+                            "minimum": 0,
+                            "maximum": 1,
+                            "decimal": 6
+                        }
+                    ]
+                },
+                {
+                    "type": "list",
+                    "key": "dict_item",
+                    "label": "DictItem in List",
+                    "object_type": {
+                        "type": "dict",
+                        "children": [
+                            {
+                                "key": "families",
+                                "label": "Families",
+                                "type": "list",
+                                "object_type": "text"
+                            },
+                            {
+                                "key": "hosts",
+                                "label": "Hosts",
+                                "type": "list",
+                                "object_type": "text"
+                            }
+                        ]
+                    }
+                },
+                {
+                    "type": "path-widget",
+                    "key": "single_path_input",
+                    "label": "Single path input",
+                    "multiplatform": false,
+                    "multipath": false
+                },
+                {
+                    "type": "path-widget",
+                    "key": "multi_path_input",
+                    "label": "Multi path input",
+                    "multiplatform": false,
+                    "multipath": true
+                },
+                {
+                    "type": "path-widget",
+                    "key": "single_os_specific_path_input",
+                    "label": "Single OS specific path input",
+                    "multiplatform": true,
+                    "multipath": false
+                },
+                {
+                    "type": "path-widget",
+                    "key": "multi_os_specific_path_input",
+                    "label": "Multi OS specific path input",
+                    "multiplatform": true,
+                    "multipath": true
+                },
+                {
+                    "key": "collapsable",
+                    "type": "dict",
+                    "label": "collapsable dictionary",
+                    "collapsable": true,
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "_nothing",
+                            "label": "Exmaple input"
+                        }
+                    ]
+                },
+                {
+                    "key": "collapsable_expanded",
+                    "type": "dict",
+                    "label": "collapsable dictionary, expanded on creation",
+                    "collapsable": true,
+                    "collapsed": false,
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "_nothing",
+                            "label": "Exmaple input"
+                        }
+                    ]
+                },
+                {
+                    "key": "not_collapsable",
+                    "type": "dict",
+                    "label": "Not collapsable",
+                    "collapsable": false,
+                    "is_group": true,
+                    "children": [
+                        {
+                            "type": "boolean",
+                            "key": "_nothing",
+                            "label": "Exmaple input"
+                        }
+                    ]
+                },
+                {
+                    "key": "nested_dict_lvl1",
+                    "type": "dict",
+                    "label": "Nested dictionary (level 1)",
+                    "children": [
+                        {
+                            "key": "nested_dict_lvl2",
+                            "type": "dict",
+                            "label": "Nested dictionary (level 2)",
+                            "is_group": true,
+                            "children": [
+                                {
+                                    "key": "nested_dict_lvl3",
+                                    "type": "dict",
+                                    "label": "Nested dictionary (level 3)",
+                                    "children": [
+                                        {
+                                            "type": "boolean",
+                                            "key": "_nothing",
+                                            "label": "Exmaple input"
+                                        }
+                                    ]
+                                },
+                                {
+                                    "key": "nested_dict_lvl3_2",
+                                    "type": "dict",
+                                    "label": "Nested dictionary (level 3) (2)",
+                                    "children": [
+                                        {
+                                            "type": "text",
+                                            "key": "_nothing",
+                                            "label": "Exmaple input"
+                                        },
+                                        {
+                                            "type": "text",
+                                            "key": "_nothing2",
+                                            "label": "Exmaple input 2"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "key": "form_examples",
+                    "type": "dict",
+                    "label": "Form examples",
+                    "children": [
+                        {
+                            "key": "inputs_without_form_example",
+                            "type": "dict",
+                            "label": "Inputs without form",
+                            "children": [
+                                {
+                                    "type": "text",
+                                    "key": "_nothing_1",
+                                    "label": "Example label"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "_nothing_2",
+                                    "label": "Example label ####"
+                                },
+                                {
+                                    "type": "text",
+                                    "key": "_nothing_3",
+                                    "label": "Example label ########"
+                                }
+                            ]
+                        },
+                        {
+                            "key": "inputs_with_form_example",
+                            "type": "dict",
+                            "label": "Inputs with form",
+                            "children": [
+                                {
+                                    "type": "form",
+                                    "children": [
+                                        {
+                                            "type": "text",
+                                            "key": "_nothing_1",
+                                            "label": "Example label"
+                                        },
+                                        {
+                                            "type": "text",
+                                            "key": "_nothing_2",
+                                            "label": "Example label ####"
+                                        },
+                                        {
+                                            "type": "text",
+                                            "key": "_nothing_3",
+                                            "label": "Example label ########"
+                                        }
+                                    ]
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type": "collapsible-wrap",
+                    "label": "Collapsible Wrapper without key",
+                    "children": [
+                        {
+                            "type": "text",
+                            "key": "_example_input_collapsible",
+                            "label": "Example input in collapsible wrapper"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/example_template.json

@@ -0,0 +1,20 @@
+[
+    {
+        "__default_values__": {
+            "multipath_executables": true
+        }
+    },
+    {
+        "type": "raw-json",
+        "label": "{host_label} Environments",
+        "key": "{host_name}_environments",
+        "env_group_key": "{host_name}"
+    },
+    {
+        "type": "path-widget",
+        "key": "{host_name}_executables",
+        "label": "{host_label} - Full paths to executables",
+        "multiplatform": "{multipath_executables}",
+        "multipath": true
+    }
+]

pype/settings/entities/schemas/system_schema/host_settings/schema_aftereffects.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "aftereffects",
+    "label": "Adobe AfterEffects",
+    "collapsable": 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",
+            "env_group_key": "aftereffects"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "2020",
+                            "host_name": "aftereffects"
+                        },
+                        {
+                            "host_version": "2021",
+                            "host_name": "aftereffects"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_blender.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "blender",
+    "label": "Blender",
+    "collapsable": 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",
+            "env_group_key": "blender"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "2.90",
+                            "host_name": "blender"
+                        },
+                        {
+                            "host_version": "2.83",
+                            "host_name": "blender"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_celaction.json

@@ -0,0 +1,48 @@
+{
+    "type": "dict",
+    "key": "celaction",
+    "label": "CelAction2D",
+    "collapsable": 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",
+            "env_group_key": "celaction"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "Local",
+                            "host_name": "celation",
+                            "multiplatform": false,
+                            "multipath_executables": false
+                        },
+                        {
+                            "host_version": "Publish",
+                            "host_name": "celation",
+                            "multiplatform": false,
+                            "multipath_executables": false
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_djv.json

@@ -0,0 +1,38 @@
+{
+    "type": "dict",
+    "key": "djvview",
+    "label": "DJV View",
+    "collapsable": 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",
+            "env_group_key": "djvview"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": {
+                        "host_version": "1.1",
+                        "host_name": "djvview"
+                    }
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_fusion.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "fusion",
+    "label": "Blackmagic Fusion",
+    "collapsable": 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",
+            "env_group_key": "fusion"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "16",
+                            "host_name": "fusion"
+                        },
+                        {
+                            "host_version": "9",
+                            "host_name": "fusion"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_harmony.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "harmony",
+    "label": "Toon Boom Harmony",
+    "collapsable": 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",
+            "env_group_key": "harmony"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "20",
+                            "host_name": "harmony"
+                        },
+                        {
+                            "host_version": "17",
+                            "host_name": "harmony"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_houdini.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "houdini",
+    "label": "SideFX Houdini",
+    "collapsable": 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",
+            "env_group_key": "houdini"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "18",
+                            "host_name": "houdini"
+                        },
+                        {
+                            "host_version": "17",
+                            "host_name": "houdini"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_maya.json

@@ -0,0 +1,48 @@
+{
+    "type": "dict",
+    "key": "maya",
+    "label": "Autodesk Maya",
+    "collapsable": 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",
+            "env_group_key": "maya"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "2020",
+                            "host_name": "maya"
+                        },
+                        {
+                            "host_version": "2019",
+                            "host_name": "maya"
+                        },
+                        {
+                            "host_version": "2018",
+                            "host_name": "maya"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_mayabatch.json

@@ -0,0 +1,48 @@
+{
+    "type": "dict",
+    "key": "mayabatch",
+    "label": "Autodesk Maya Batch",
+    "collapsable": 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",
+            "env_group_key": "mayabatch"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "2020",
+                            "host_name": "mayabatch"
+                        },
+                        {
+                            "host_version": "2019",
+                            "host_name": "mayabatch"
+                        },
+                        {
+                            "host_version": "2018",
+                            "host_name": "mayabatch"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_photoshop.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "photoshop",
+    "label": "Adobe Photoshop",
+    "collapsable": 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",
+            "env_group_key": "photoshop"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "2020",
+                            "host_name": "photoshop"
+                        },
+                        {
+                            "host_version": "2021",
+                            "host_name": "photoshop"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_resolve.json

@@ -0,0 +1,40 @@
+{
+    "type": "dict",
+    "key": "resolve",
+    "label": "Blackmagic DaVinci Resolve",
+    "collapsable": 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",
+            "env_group_key": "resolve"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "16",
+                            "host_name": "resolve"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_shell.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "shell",
+    "label": "Shell",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "children": [
+        {
+            "type": "boolean",
+            "key": "enabled",
+            "label": "Enabled"
+        },
+        {
+            "key": "environment",
+            "label": "Environment",
+            "type": "raw-json",
+            "env_group_key": "shell"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "Python 3.7",
+                            "host_name": "python"
+                        },
+                        {
+                            "host_version": "Python 2.7",
+                            "host_name": "python"
+                        },
+                        {
+                            "host_version": "Terminal",
+                            "host_name": "terminal"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_tvpaint.json

@@ -0,0 +1,44 @@
+{
+    "type": "dict",
+    "key": "tvpaint",
+    "label": "TVPaint",
+    "collapsable": 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",
+            "env_group_key": "tvpaint"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "Animation 11 (64bits)",
+                            "host_name": "tvpaint"
+                        },
+                        {
+                            "host_version": "Animation 11 (32bits)",
+                            "host_name": "tvpaint"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/schema_unreal.json

@@ -0,0 +1,40 @@
+{
+    "type": "dict",
+    "key": "unreal",
+    "label": "Unreal Editor",
+    "collapsable": 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",
+            "env_group_key": "unreal"
+        },
+        {
+            "type": "dict",
+            "key": "variants",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_host_variant",
+                    "template_data": [
+                        {
+                            "host_version": "4.24",
+                            "host_name": "unreal"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/host_settings/template_host_unchangables.json

@@ -0,0 +1,38 @@
+[
+    {
+        "type": "text",
+        "key": "label",
+        "label": "Label",
+        "placeholder": "Host label (without any version)",
+        "roles": ["developer"]
+    },
+    {
+        "type": "text",
+        "key": "icon",
+        "label": "Icon",
+        "placeholder": "Host icon path template",
+        "roles": ["developer"]
+    },
+    {
+        "type": "enum",
+        "key": "host_name",
+        "label": "Host implementation",
+        "enum_items": [
+            { "": "< without host >" },
+            { "aftereffects": "aftereffects" },
+            { "blender": "blender" },
+            { "celaction": "celaction" },
+            { "fusion": "fusion" },
+            { "harmony": "harmony" },
+            { "hiero": "hiero" },
+            { "houdini": "houdini" },
+            { "maya": "maya" },
+            { "nuke": "nuke" },
+            { "photoshop": "photoshop" },
+            { "resolve": "resolve" },
+            { "tvpaint": "tvpaint" },
+            { "unreal": "unreal" }
+        ],
+        "roles": ["developer"]
+    }
+]

pype/settings/entities/schemas/system_schema/host_settings/template_host_variant.json

@@ -0,0 +1,57 @@
+[
+    {
+        "__default_values__": {
+            "multipath_executables": true,
+            "multiplatform": true
+        }
+    },
+    {
+        "type": "dict",
+        "key": "{host_name}_{host_version}",
+        "label": "{host_version}",
+        "collapsable": true,
+        "checkbox_key": "enabled",
+        "children": [
+            {
+                "type": "boolean",
+                "key": "enabled",
+                "label": "Enabled"
+            },
+            {
+                "type": "text",
+                "key": "label",
+                "label": "Label",
+                "placeholder": "Used from host label if not filled.",
+                "roles": ["developer"]
+            },
+            {
+                "type": "text",
+                "key": "variant_label",
+                "label": "Variant label",
+                "placeholder": "Only \"Label\" is used if not filled.",
+                "roles": ["developer"]
+            },
+            {
+                "type": "text",
+                "key": "icon",
+                "label": "Icon",
+                "placeholder": "Host icon path template. Used from host if not filled.",
+                "roles": ["developer"]
+            },
+            {
+                "type": "path-widget",
+                "key": "executables",
+                "label": "Executables",
+                "multiplatform": "{multiplatform}",
+                "multipath": "{multipath_executables}",
+                "with_arguments": true
+            },
+            {
+                "key": "environment",
+                "label": "Environment",
+                "type": "raw-json",
+                "env_group_key": "{host_name}_{host_version}"
+            }
+        ]
+    }
+]

pype/settings/entities/schemas/system_schema/host_settings/template_nuke.json

@@ -0,0 +1,58 @@
+[
+    {
+        "type": "dict",
+        "key": "{nuke_type}",
+        "label": "Foundry {nuke_label}",
+        "collapsable": 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",
+                "env_group_key": "{nuke_type}"
+            },
+            {
+                "type": "dict",
+                "key": "variants",
+                "children": [
+                    {
+                        "type": "schema_template",
+                        "name": "template_host_variant",
+                        "template_data": [
+                            {
+                                "host_version": "12.2",
+                                "host_name": "{nuke_type}",
+                                "multipath_executables": true
+                            },
+                            {
+                                "host_version": "12.0",
+                                "host_name": "{nuke_type}",
+                                "multipath_executables": true
+                            },
+                            {
+                                "host_version": "11.3",
+                                "host_name": "{nuke_type}",
+                                "multipath_executables": true
+                            },
+                            {
+                                "host_version": "11.2",
+                                "host_name": "{nuke_type}",
+                                "multipath_executables": true
+                            }
+                        ]
+                    }
+                ]
+            }
+        ]
+    }
+]

pype/settings/entities/schemas/system_schema/module_settings/schema_ftrack.json

@@ -0,0 +1,163 @@
+{
+    "type": "dict",
+    "key": "ftrack",
+    "label": "Ftrack",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "children": [
+        {
+            "type": "boolean",
+            "key": "enabled",
+            "label": "Enabled"
+        },
+        {
+            "type": "text",
+            "key": "ftrack_server",
+            "label": "Server"
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "type": "label",
+            "label": "Additional Ftrack paths"
+        },
+        {
+            "type": "list",
+            "key": "ftrack_actions_path",
+            "label": "Action paths",
+            "object_type": "text"
+        },
+        {
+            "type": "list",
+            "key": "ftrack_events_path",
+            "label": "Event paths",
+            "object_type": "text"
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "type": "label",
+            "label": "Ftrack event server advanced settings"
+        },
+        {
+            "type": "text",
+            "key": "mongo_database_name",
+            "label": "Event Mongo DB"
+        },
+        {
+            "type": "text",
+            "key": "mongo_collection_name",
+            "label": "Events Mongo Collection"
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "key": "intent",
+            "type": "dict",
+            "label": "Intent",
+            "collapsable_key": true,
+            "is_group": true,
+            "children": [
+                {
+                    "type": "label",
+                    "label": "Intent"
+                },
+                {
+                    "type": "dict-modifiable",
+                    "object_type": "text",
+                    "key": "items"
+                },
+                {
+                    "type": "label",
+                    "label": " "
+                },
+                {
+                    "key": "default",
+                    "type": "text",
+                    "label": "Default Intent"
+                }
+            ]
+        },
+        {
+            "key": "custom_attributes",
+            "label": "Custom Attributes",
+            "type": "dict",
+            "children": [
+                {
+                    "type": "dict",
+                    "key": "show",
+                    "label": "Project Custom attributes",
+                    "children": [
+                        {
+                            "type": "schema_template",
+                            "name": "template_custom_attribute",
+                            "template_data": [
+                                {
+                                    "key": "avalon_auto_sync"
+                                },
+                                {
+                                    "key": "library_project"
+                                },
+                                {
+                                    "key": "applications"
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    "type": "dict",
+                    "key": "is_hierarchical",
+                    "label": "Hierarchical Attributes",
+                    "children": [
+                        {
+                            "type": "schema_template",
+                            "name": "template_custom_attribute",
+                            "template_data": [
+                                {
+                                    "key": "tools_env"
+                                },
+                                {
+                                    "key": "avalon_mongo_id"
+                                },
+                                {
+                                    "key": "fps"
+                                },
+                                {
+                                    "key": "frameStart"
+                                },
+                                {
+                                    "key": "frameEnd"
+                                },
+                                {
+                                    "key": "clipIn"
+                                },
+                                {
+                                    "key": "clipOut"
+                                },
+                                {
+                                    "key": "handleStart"
+                                },
+                                {
+                                    "key": "handleEnd"
+                                },
+                                {
+                                    "key": "resolutionWidth"
+                                },
+                                {
+                                    "key": "resolutionHeight"
+                                },
+                                {
+                                    "key": "pixelAspect"
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/module_settings/template_custom_attribute.json

@@ -0,0 +1,21 @@
+[
+    {
+        "key": "{key}",
+        "label": "{key}",
+        "type": "dict",
+        "children": [
+            {
+                "key": "write_security_roles",
+                "label": "Write roles",
+                "type": "list",
+                "object_type": "text"
+            },
+            {
+                "key": "read_security_roles",
+                "label": "Read roles",
+                "type": "list",
+                "object_type": "text"
+            }
+        ]
+    }
+]

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

@@ -0,0 +1,97 @@
+{
+  "key": "applications",
+  "type": "dict",
+  "label": "Applications",
+  "collapsable": true,
+  "is_file": true,
+  "children": [
+    {
+      "type": "schema",
+      "name": "schema_maya"
+    },
+    {
+      "type": "schema",
+      "name": "schema_mayabatch"
+    },
+    {
+      "type": "schema_template",
+      "name": "template_nuke",
+      "template_data": {
+        "nuke_type": "nuke",
+        "nuke_label": "Nuke"
+      }
+    },
+    {
+      "type": "schema_template",
+      "name": "template_nuke",
+      "template_data": {
+        "nuke_type": "nukex",
+        "nuke_label": "Nuke X"
+      }
+    },
+    {
+      "type": "schema_template",
+      "name": "template_nuke",
+      "template_data": {
+        "nuke_type": "nukestudio",
+        "nuke_label": "Nuke Studio"
+      }
+    },
+    {
+      "type": "schema_template",
+      "name": "template_nuke",
+      "template_data": {
+        "nuke_type": "hiero",
+        "nuke_label": "Hiero"
+      }
+    },
+    {
+      "type": "schema",
+      "name": "schema_fusion"
+    },
+    {
+      "type": "schema",
+      "name": "schema_resolve"
+    },
+    {
+      "type": "schema",
+      "name": "schema_houdini"
+    },
+    {
+      "type": "schema",
+      "name": "schema_blender"
+    },
+    {
+      "type": "schema",
+      "name": "schema_harmony"
+    },
+    {
+      "type": "schema",
+      "name": "schema_tvpaint"
+    },
+    {
+      "type": "schema",
+      "name": "schema_photoshop"
+    },
+    {
+      "type": "schema",
+      "name": "schema_aftereffects"
+    },
+    {
+      "type": "schema",
+      "name": "schema_celaction"
+    },
+    {
+      "type": "schema",
+      "name": "schema_unreal"
+    },
+    {
+      "type": "schema",
+      "name": "schema_shell"
+    },
+    {
+      "type": "schema",
+      "name": "schema_djv"
+    }
+  ]
+}

pype/settings/entities/schemas/system_schema/schema_general.json

@@ -0,0 +1,45 @@
+{
+    "key": "general",
+    "type": "dict",
+    "label": "General",
+    "collapsable": true,
+    "is_file": true,
+    "children": [
+        {
+            "key": "studio_name",
+            "type": "text",
+            "label": "Studio Name"
+        },
+        {
+            "key": "studio_code",
+            "type": "text",
+            "label": "Studio Short Code"
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "key": "project_plugins",
+            "type": "path-widget",
+            "label": "Additional Project Plugins Path",
+            "multiplatform": true,
+            "multipath": false
+        },
+        {
+            "key": "studio_soft",
+            "type": "path-widget",
+            "label": "Studio Software Location",
+            "multiplatform": true,
+            "multipath": false
+        },
+        {
+            "type": "splitter"
+        },
+        {
+            "key": "environment",
+            "label": "Environment",
+            "type": "raw-json",
+            "env_group_key": "global"
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/schema_main.json

@@ -0,0 +1,22 @@
+{
+    "key": "system",
+    "type": "dict",
+    "children": [
+        {
+            "type": "schema",
+            "name": "schema_general"
+        },
+        {
+            "type": "schema",
+            "name": "schema_modules"
+        },
+        {
+            "type": "schema",
+            "name": "schema_applications"
+        },
+        {
+            "type": "schema",
+            "name": "schema_tools"
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/schema_modules.json

@@ -0,0 +1,231 @@
+{
+    "key": "modules",
+    "type": "dict",
+    "label": "Modules",
+    "collapsable": true,
+    "is_file": true,
+    "children": [
+        {
+            "type": "dict",
+            "key": "avalon",
+            "label": "Avalon",
+            "collapsable": true,
+            "children": [
+                {
+                    "type": "text",
+                    "key": "AVALON_MONGO",
+                    "label": "Avalon Mongo URL",
+                    "placeholder": "Pype Mongo is used if not filled."
+                },
+                {
+                    "type": "number",
+                    "key": "AVALON_TIMEOUT",
+                    "minimum": 0,
+                    "label": "Avalon Mongo Timeout (ms)"
+                },
+                {
+                    "type": "path-widget",
+                    "label": "Thumbnail Storage Location",
+                    "key": "AVALON_THUMBNAIL_ROOT",
+                    "multiplatform": true,
+                    "multipath": false
+                },
+                {
+                    "type": "text",
+                    "key": "AVALON_DB_DATA",
+                    "label": "Avalon Mongo Data Location"
+                }
+            ]
+        },
+        {
+            "type": "schema",
+            "name": "schema_ftrack"
+        },
+        {
+            "type": "dict",
+            "key": "rest_api",
+            "label": "Rest Api",
+            "collapsable": true,
+            "children": [
+                {
+                    "type": "number",
+                    "key": "default_port",
+                    "label": "Default Port",
+                    "minimum": 1,
+                    "maximum": 65535
+                },
+                {
+                    "type": "list",
+                    "key": "exclude_ports",
+                    "label": "Exclude ports",
+                    "object_type": {
+                        "type": "number",
+                        "minimum": 1,
+                        "maximum": 65535
+                    }
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "timers_manager",
+            "label": "Timers Manager",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "number",
+                    "decimal": 2,
+                    "key": "full_time",
+                    "label": "Max idle time"
+                },
+                {
+                    "type": "number",
+                    "decimal": 2,
+                    "key": "message_time",
+                    "label": "When dialog will show"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "clockify",
+            "label": "Clockify",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "text",
+                    "key": "workspace_name",
+                    "label": "Workspace name"
+                }
+            ]
+        },  {
+            "type": "dict",
+            "key": "sync_server",
+            "label": "Sync Server",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [{
+                  "type": "boolean",
+                  "key": "enabled",
+                  "label": "Enabled"
+            }]
+        },{
+            "type": "dict",
+            "key": "deadline",
+            "label": "Deadline",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "text",
+                    "key": "DEADLINE_REST_URL",
+                    "label": "Deadline Resl URL"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "muster",
+            "label": "Muster",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                },
+                {
+                    "type": "text",
+                    "key": "MUSTER_REST_URL",
+                    "label": "Muster Rest URL"
+                },
+                {
+                    "type": "dict-modifiable",
+                    "object_type": {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 300
+                    },
+                    "is_group": true,
+                    "key": "templates_mapping",
+                    "label": "Templates mapping",
+                    "is_file": true
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "log_viewer",
+            "label": "Logging",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "user",
+            "label": "User setting",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "standalonepublish_tool",
+            "label": "Standalone Publish",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        },
+        {
+            "type": "dict",
+            "key": "idle_manager",
+            "label": "Idle Manager",
+            "collapsable": true,
+            "checkbox_key": "enabled",
+            "children": [
+                {
+                    "type": "boolean",
+                    "key": "enabled",
+                    "label": "Enabled"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/schema_tools.json

@@ -0,0 +1,37 @@
+{
+    "key": "tools",
+    "type": "dict",
+    "label": "Tools",
+    "collapsable": true,
+    "is_file": true,
+    "children": [
+        {
+            "type": "schema",
+            "name": "schema_arnold"
+        },
+        {
+            "type": "schema",
+            "name": "schema_vray"
+        },
+        {
+            "type": "schema",
+            "name": "schema_yeti"
+        },
+        {
+            "type": "dict",
+            "key": "other",
+            "children": [
+                {
+                    "type": "schema_template",
+                    "name": "template_tool_variant",
+                    "template_data": [
+                        {
+                            "tool_name": "othertools",
+                            "tool_label": "Other Tools and Plugins"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/tool_settings/schema_arnold.json

@@ -0,0 +1,29 @@
+{
+    "type": "dict",
+    "key": "mtoa",
+    "label": "Autodesk Arnold",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "children": [
+        {
+            "type": "boolean",
+            "key": "enabled",
+            "label": "Enabled"
+        },
+        {
+            "key": "environment",
+            "label": "Environment (mtoa)",
+            "type": "raw-json",
+            "env_group_key": "mtoa"
+        },
+        {
+            "type": "schema_template",
+            "name": "template_tool_variant",
+            "template_data": [
+                {
+                    "tool_label": "Arnold Versions"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/tool_settings/schema_vray.json

@@ -0,0 +1,28 @@
+{
+    "type": "dict",
+    "key": "vray",
+    "label": "Chaos Group Vray",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "children": [
+        {
+            "type": "boolean",
+            "key": "enabled",
+            "label": "Enabled"
+        },
+        {
+            "key": "environment",
+            "label": "Environment",
+            "type": "raw-json"
+        },
+        {
+            "type": "schema_template",
+            "name": "template_tool_variant",
+            "template_data": [
+                {
+                    "tool_label": "Vray Versions"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/tool_settings/schema_yeti.json

@@ -0,0 +1,28 @@
+{
+    "type": "dict",
+    "key": "yeti",
+    "label": "Pergrine Labs Yeti",
+    "collapsable": true,
+    "checkbox_key": "enabled",
+    "children": [
+        {
+            "type": "boolean",
+            "key": "enabled",
+            "label": "Enabled"
+        },
+        {
+            "key": "environment",
+            "label": "Environment",
+            "type": "raw-json"
+        },
+        {
+            "type": "schema_template",
+            "name": "template_tool_variant",
+            "template_data": [
+                {
+                    "tool_label": "Yeti Versions"
+                }
+            ]
+        }
+    ]
+}

pype/settings/entities/schemas/system_schema/tool_settings/template_tool_variant.json

@@ -0,0 +1,11 @@
+[
+    {
+        "type": "dict-modifiable",
+        "key": "variants",
+        "label": "{tool_label}",
+        "value_is_env_group": true,
+        "object_type": {
+            "type": "raw-json"
+        }
+    }
+]