Merge branch 'develop' into bugfix/author_integrate

.gitmodules

@@ -1,3 +1,3 @@
 [submodule "client/ayon_core/hosts/unreal/integration"]
-	path = client/ayon_core/hosts/unreal/integration
+	path = server_addon/unreal/client/ayon_unreal/integration
 	url = https://github.com/ynput/ayon-unreal-plugin.git

client/ayon_core/addon/README.md

@@ -35,14 +35,14 @@ AYON addons should contain separated logic of specific kind of implementation, s
 - addon has more logic when used in a tray
  - it is possible that addon can be used only in the tray
 - abstract methods
- - `tray_init` - initialization triggered after `initialize` when used in `TrayModulesManager` and before `connect_with_addons`
+ - `tray_init` - initialization triggered after `initialize` when used in `TrayAddonsManager` and before `connect_with_addons`
  - `tray_menu` - add actions to tray widget's menu that represent the addon
  - `tray_start` - start of addon's login in tray
  - addon is initialized and connected with other addons
  - `tray_exit` - addon's cleanup like stop and join threads etc.
- - order of calling is based on implementation this order is how it works with `TrayModulesManager`
+ - order of calling is based on implementation this order is how it works with `TrayAddonsManager`
  - it is recommended to import and use GUI implementation only in these methods
-- has attribute `tray_initialized` (bool) which is set to False by default and is set by `TrayModulesManager` to True after `tray_init`
+- has attribute `tray_initialized` (bool) which is set to False by default and is set by `TrayAddonsManager` to True after `tray_init`
  - if addon has logic only in tray or for both then should be checking for `tray_initialized` attribute to decide how should handle situations
 
 ### ITrayService

client/ayon_core/addon/base.py

@@ -8,7 +8,6 @@ import inspect
 import logging
 import threading
 import collections
-
 from uuid import uuid4
 from abc import ABCMeta, abstractmethod
 
@@ -38,32 +37,33 @@ IGNORED_DEFAULT_FILENAMES = (
     "base.py",
     "interfaces.py",
     "click_wrap.py",
-    "example_addons",
-    "default_modules",
 )
-IGNORED_HOSTS_IN_AYON = {
-    "flame",
-    "harmony",
-}
-IGNORED_MODULES_IN_AYON = set()
 
 # When addon was moved from ayon-core codebase
 # - this is used to log the missing addon
 MOVED_ADDON_MILESTONE_VERSIONS = {
+    "aftereffects": VersionInfo(0, 2, 0),
     "applications": VersionInfo(0, 2, 0),
+    "blender": VersionInfo(0, 2, 0),
     "celaction": VersionInfo(0, 2, 0),
     "clockify": VersionInfo(0, 2, 0),
+    "deadline": VersionInfo(0, 2, 0),
     "flame": VersionInfo(0, 2, 0),
     "fusion": VersionInfo(0, 2, 0),
+    "harmony": VersionInfo(0, 2, 0),
+    "hiero": VersionInfo(0, 2, 0),
     "max": VersionInfo(0, 2, 0),
     "photoshop": VersionInfo(0, 2, 0),
+    "timers_manager": VersionInfo(0, 2, 0),
     "traypublisher": VersionInfo(0, 2, 0),
     "tvpaint": VersionInfo(0, 2, 0),
     "maya": VersionInfo(0, 2, 0),
     "nuke": VersionInfo(0, 2, 0),
     "resolve": VersionInfo(0, 2, 0),
+    "royalrender": VersionInfo(0, 2, 0),
     "substancepainter": VersionInfo(0, 2, 0),
     "houdini": VersionInfo(0, 3, 0),
+    "unreal": VersionInfo(0, 2, 0),
 }
 
 
@@ -414,12 +414,6 @@ def _load_addons_in_core(
     hosts_dir = os.path.join(AYON_CORE_ROOT, "hosts")
     modules_dir = os.path.join(AYON_CORE_ROOT, "modules")
 
-    ignored_host_names = set(IGNORED_HOSTS_IN_AYON)
-    ignored_module_dir_filenames = (
-        set(IGNORED_DEFAULT_FILENAMES)
-        | IGNORED_MODULES_IN_AYON
-    )
-
     for dirpath in {hosts_dir, modules_dir}:
         if not os.path.exists(dirpath):
             log.warning((
@@ -428,10 +422,9 @@ def _load_addons_in_core(
             continue
 
         is_in_modules_dir = dirpath == modules_dir
+        ignored_filenames = set()
         if is_in_modules_dir:
-            ignored_filenames = ignored_module_dir_filenames
-        else:
-            ignored_filenames = ignored_host_names
+            ignored_filenames = set(IGNORED_DEFAULT_FILENAMES)
 
         for filename in os.listdir(dirpath):
             # Ignore filenames
@@ -497,9 +490,6 @@ def _load_addons_in_core(
 
 
 def _load_addons():
-    # Support to use 'openpype' imports
-    sys.modules["openpype"] = sys.modules["ayon_core"]
-
     # Key under which will be modules imported in `sys.modules`
     modules_key = "openpype_modules"
 
@@ -552,6 +542,9 @@ class AYONAddon(object):
     enabled = True
     _id = None
 
+    # Temporary variable for 'version' property
+    _missing_version_warned = False
+
     def __init__(self, manager, settings):
         self.manager = manager
 
@@ -582,6 +575,26 @@ class AYONAddon(object):
 
         pass
 
+    @property
+    def version(self):
+        """Addon version.
+
+        Todo:
+            Should be abstract property (required). Introduced in
+                ayon-core 0.3.3 .
+
+        Returns:
+            str: Addon version as semver compatible string.
+
+        """
+        if not self.__class__._missing_version_warned:
+            self.__class__._missing_version_warned = True
+            print(
+                f"DEV WARNING: Addon '{self.name}' does not have"
+                f" defined version."
+            )
+        return "0.0.0"
+
     def initialize(self, settings):
         """Initialization of addon attributes.
 
@@ -697,6 +710,30 @@ class OpenPypeAddOn(OpenPypeModule):
     enabled = True
 
 
+class _AddonReportInfo:
+    def __init__(
+        self, class_name, name, version, report_value_by_label
+    ):
+        self.class_name = class_name
+        self.name = name
+        self.version = version
+        self.report_value_by_label = report_value_by_label
+
+    @classmethod
+    def from_addon(cls, addon, report):
+        class_name = addon.__class__.__name__
+        report_value_by_label = {
+            label: reported.get(class_name)
+            for label, reported in report.items()
+        }
+        return cls(
+            addon.__class__.__name__,
+            addon.name,
+            addon.version,
+            report_value_by_label
+        )
+
+
 class AddonsManager:
     """Manager of addons that helps to load and prepare them to work.
 
@@ -873,10 +910,6 @@ class AddonsManager:
                 name_alias = getattr(addon, "openpype_alias", None)
                 if name_alias:
                     aliased_names.append((name_alias, addon))
-                enabled_str = "X"
-                if not addon.enabled:
-                    enabled_str = " "
-                self.log.debug("[{}] {}".format(enabled_str, name))
 
                 now = time.time()
                 report[addon.__class__.__name__] = now - prev_start_time
@@ -888,6 +921,13 @@ class AddonsManager:
                     exc_info=True
                 )
 
+        for addon_name in sorted(self._addons_by_name.keys()):
+            addon = self._addons_by_name[addon_name]
+            enabled_str = "X" if addon.enabled else " "
+            self.log.debug(
+                f"[{enabled_str}] {addon.name} ({addon.version})"
+            )
+
         for item in aliased_names:
             name_alias, addon = item
             if name_alias not in self._addons_by_name:
@@ -1176,39 +1216,55 @@ class AddonsManager:
             available_col_names |= set(addon_names.keys())
 
         # Prepare ordered dictionary for columns
-        cols = collections.OrderedDict()
-        # Add addon names to first columnt
-        cols["Addon name"] = list(sorted(
-            addon.__class__.__name__
+        addons_info = [
+            _AddonReportInfo.from_addon(addon, self._report)
             for addon in self.addons
             if addon.__class__.__name__ in available_col_names
-        ))
+        ]
+        addons_info.sort(key=lambda x: x.name)
+
+        addon_name_rows = [
+            addon_info.name
+            for addon_info in addons_info
+        ]
+        addon_version_rows = [
+            addon_info.version
+            for addon_info in addons_info
+        ]
+
         # Add total key (as last addon)
-        cols["Addon name"].append(self._report_total_key)
+        addon_name_rows.append(self._report_total_key)
+        addon_version_rows.append(f"({len(addons_info)})")
+
+        cols = collections.OrderedDict()
+        # Add addon names to first columnt
+        cols["Addon name"] = addon_name_rows
+        cols["Version"] = addon_version_rows
 
         # Add columns from report
+        total_by_addon = {
+            row: 0
+            for row in addon_name_rows
+        }
         for label in self._report.keys():
-            cols[label] = []
-
-        total_addon_times = {}
-        for addon_name in cols["Addon name"]:
-            total_addon_times[addon_name] = 0
-
-        for label, reported in self._report.items():
-            for addon_name in cols["Addon name"]:
-                col_time = reported.get(addon_name)
-                if col_time is None:
-                    cols[label].append("N/A")
+            rows = []
+            col_total = 0
+            for addon_info in addons_info:
+                value = addon_info.report_value_by_label.get(label)
+                if value is None:
+                    rows.append("N/A")
                     continue
-                cols[label].append("{:.3f}".format(col_time))
-                total_addon_times[addon_name] += col_time
-
+                rows.append("{:.3f}".format(value))
+                total_by_addon[addon_info.name] += value
+                col_total += value
+            total_by_addon[self._report_total_key] += col_total
+            rows.append("{:.3f}".format(col_total))
+            cols[label] = rows
         # Add to also total column that should sum the row
-        cols[self._report_total_key] = []
-        for addon_name in cols["Addon name"]:
-            cols[self._report_total_key].append(
-                "{:.3f}".format(total_addon_times[addon_name])
-            )
+        cols[self._report_total_key] = [
+            "{:.3f}".format(total_by_addon[addon_name])
+            for addon_name in cols["Addon name"]
+        ]
 
         # Prepare column widths and total row count
         # - column width is by

client/ayon_core/cli.py

@@ -268,7 +268,7 @@ def main(*args, **kwargs):
         os.path.join(AYON_CORE_ROOT, "tools"),
         # add common AYON vendor
         # (common for multiple Python interpreter versions)
-        os.path.join(AYON_CORE_ROOT, "vendor", "python", "common")
+        os.path.join(AYON_CORE_ROOT, "vendor", "python")
     ]
     for path in additional_paths:
         if path not in split_paths:

client/ayon_core/cli_commands.py

@@ -36,7 +36,7 @@ class Commands:
                 log.warning(
                     "Failed to add cli command for module \"{}\"".format(
                         addon.name
-                    )
+                    ), exc_info=True
                 )
         return click_func
 

client/ayon_core/hosts/blender/__init__.py

@@ -1,6 +0,0 @@
-from .addon import BlenderAddon
-
-
-__all__ = (
-    "BlenderAddon",
-)

client/ayon_core/hosts/hiero/__init__.py

@@ -1,10 +0,0 @@
-from .addon import (
-    HIERO_ROOT_DIR,
-    HieroAddon,
-)
-
-
-__all__ = (
-    "HIERO_ROOT_DIR",
-    "HieroAddon",
-)

client/ayon_core/hosts/unreal/__init__.py

@@ -1,6 +0,0 @@
-from .addon import UnrealAddon
-
-
-__all__ = (
-    "UnrealAddon",
-)

client/ayon_core/lib/__init__.py

@@ -1,19 +1,6 @@
 # -*- coding: utf-8 -*-
 # flake8: noqa E402
 """AYON lib functions."""
-# add vendor to sys path based on Python version
-import sys
-import os
-import site
-from ayon_core import AYON_CORE_ROOT
-
-# Add Python version specific vendor folder
-python_version_dir = os.path.join(
-    AYON_CORE_ROOT, "vendor", "python", "python_{}".format(sys.version[0])
-)
-# Prepend path in sys paths
-sys.path.insert(0, python_version_dir)
-site.addsitedir(python_version_dir)
 
 from .local_settings import (
     IniSettingRegistry,

client/ayon_core/lib/attribute_definitions.py

@@ -281,7 +281,7 @@ class HiddenDef(AbstractAttrDef):
     def __init__(self, key, default=None, **kwargs):
         kwargs["default"] = default
         kwargs["hidden"] = True
-        super(UnknownDef, self).__init__(key, **kwargs)
+        super(HiddenDef, self).__init__(key, **kwargs)
 
     def convert_value(self, value):
         return value

client/ayon_core/modules/deadline/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.12"

client/ayon_core/modules/launcher_action.py

@@ -7,6 +7,7 @@ from ayon_core.addon import AYONAddon, ITrayAction
 class LauncherAction(AYONAddon, ITrayAction):
     label = "Launcher"
     name = "launcher_tool"
+    version = "1.0.0"
 
     def initialize(self, settings):
 

client/ayon_core/modules/loader_action.py

@@ -3,6 +3,7 @@ from ayon_core.addon import AYONAddon, ITrayAddon
 
 class LoaderAddon(AYONAddon, ITrayAddon):
     name = "loader_tool"
+    version = "1.0.0"
 
     def initialize(self, settings):
         # Tray attributes

client/ayon_core/modules/python_console_interpreter/addon.py

@@ -4,6 +4,7 @@ from ayon_core.addon import AYONAddon, ITrayAction
 class PythonInterpreterAction(AYONAddon, ITrayAction):
     label = "Console"
     name = "python_interpreter"
+    version = "1.0.0"
     admin_action = True
 
     def initialize(self, settings):

client/ayon_core/modules/webserver/__init__.py

@@ -1,8 +1,13 @@
+from .version import __version__
+from .structures import HostMsgAction
 from .webserver_module import (
     WebServerAddon
 )
 
 
 __all__ = (
+    "__version__",
+
+    "HostMsgAction",
     "WebServerAddon",
 )

client/ayon_core/modules/webserver/host_console_listener.py

@@ -9,22 +9,18 @@ from qtpy import QtWidgets
 from ayon_core.addon import ITrayService
 from ayon_core.tools.stdout_broker.window import ConsoleDialog
 
+from .structures import HostMsgAction
+
 log = logging.getLogger(__name__)
 
 
+# Host listener icon type
 class IconType:
     IDLE = "idle"
     RUNNING = "running"
     FAILED = "failed"
 
 
-class MsgAction:
-    CONNECTING = "connecting"
-    INITIALIZED = "initialized"
-    ADD = "add"
-    CLOSE = "close"
-
-
 class HostListener:
     def __init__(self, webserver, module):
         self._window_per_id = {}
@@ -96,22 +92,22 @@ class HostListener:
                 if msg.type == aiohttp.WSMsgType.TEXT:
                     host_name, action, text = self._parse_message(msg)
 
-                    if action == MsgAction.CONNECTING:
+                    if action == HostMsgAction.CONNECTING:
                         self._action_per_id[host_name] = None
                         # must be sent to main thread, or action wont trigger
                         self.module.execute_in_main_thread(
                             lambda: self._host_is_connecting(host_name, text))
-                    elif action == MsgAction.CLOSE:
+                    elif action == HostMsgAction.CLOSE:
                         # clean close
                         self._close(host_name)
                         await ws.close()
-                    elif action == MsgAction.INITIALIZED:
+                    elif action == HostMsgAction.INITIALIZED:
                         self.module.execute_in_main_thread(
                             # must be queued as _host_is_connecting might not
                             # be triggered/finished yet
                             lambda: self._set_host_icon(host_name,
                                                         IconType.RUNNING))
-                    elif action == MsgAction.ADD:
+                    elif action == HostMsgAction.ADD:
                         self.module.execute_in_main_thread(
                             lambda: self._add_text(host_name, text))
                 elif msg.type == aiohttp.WSMsgType.ERROR:

client/ayon_core/modules/webserver/structures.py

@@ -0,0 +1,6 @@
+# Host listener message actions
+class HostMsgAction:
+    CONNECTING = "connecting"
+    INITIALIZED = "initialized"
+    ADD = "add"
+    CLOSE = "close"

client/ayon_core/modules/webserver/version.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

client/ayon_core/modules/webserver/webserver_module.py

@@ -26,9 +26,12 @@ import socket
 from ayon_core import resources
 from ayon_core.addon import AYONAddon, ITrayService
 
+from .version import __version__
+
 
 class WebServerAddon(AYONAddon, ITrayService):
     name = "webserver"
+    version = __version__
     label = "WebServer"
 
     webserver_url_env = "AYON_WEBSERVER_URL"

client/ayon_core/pipeline/context_tools.py

@@ -11,7 +11,12 @@ from pyblish.lib import MessageHandler
 
 from ayon_core import AYON_CORE_ROOT
 from ayon_core.host import HostBase
-from ayon_core.lib import is_in_tests, initialize_ayon_connection, emit_event
+from ayon_core.lib import (
+    is_in_tests,
+    initialize_ayon_connection,
+    emit_event,
+    version_up
+)
 from ayon_core.addon import load_addons, AddonsManager
 from ayon_core.settings import get_project_settings
 
@@ -21,6 +26,8 @@ from .template_data import get_template_data_with_names
 from .workfile import (
     get_workdir,
     get_custom_workfile_template_by_string_context,
+    get_workfile_template_key_from_context,
+    get_last_workfile
 )
 from . import (
     register_loader_plugin_path,
@@ -579,3 +586,48 @@ def get_process_id():
     if _process_id is None:
         _process_id = str(uuid.uuid4())
     return _process_id
+
+
+def version_up_current_workfile():
+    """Function to increment and save workfile
+    """
+    host = registered_host()
+    if not host.has_unsaved_changes():
+        print("No unsaved changes, skipping file save..")
+        return
+
+    project_name = get_current_project_name()
+    folder_path = get_current_folder_path()
+    task_name = get_current_task_name()
+    host_name = get_current_host_name()
+
+    template_key = get_workfile_template_key_from_context(
+        project_name,
+        folder_path,
+        task_name,
+        host_name,
+    )
+    anatomy = Anatomy(project_name)
+
+    data = get_template_data_with_names(
+        project_name, folder_path, task_name, host_name
+    )
+    data["root"] = anatomy.roots
+
+    work_template = anatomy.get_template_item("work", template_key)
+
+    # Define saving file extension
+    extensions = host.get_workfile_extensions()
+    current_file = host.get_current_workfile()
+    if current_file:
+        extensions = [os.path.splitext(current_file)[-1]]
+
+    work_root = work_template["directory"].format_strict(data)
+    file_template = work_template["file"].template
+    last_workfile_path = get_last_workfile(
+        work_root, file_template, data, extensions, True
+    )
+    new_workfile_path = version_up(last_workfile_path)
+    if os.path.exists(new_workfile_path):
+        new_workfile_path = version_up(new_workfile_path)
+    host.save_workfile(new_workfile_path)

client/ayon_core/pipeline/create/context.py

@@ -37,6 +37,7 @@ from .creator_plugins import (
 
 # Changes of instances and context are send as tuple of 2 information
 UpdateData = collections.namedtuple("UpdateData", ["instance", "changes"])
+_NOT_SET = object()
 
 
 class UnavailableSharedData(Exception):
@@ -1401,6 +1402,11 @@ class CreateContext:
         self._current_folder_path = None
         self._current_task_name = None
         self._current_workfile_path = None
+        self._current_project_settings = None
+
+        self._current_folder_entity = _NOT_SET
+        self._current_task_entity = _NOT_SET
+        self._current_task_type = _NOT_SET
 
         self._current_project_anatomy = None
 
@@ -1571,6 +1577,64 @@ class CreateContext:
 
         return self._current_task_name
 
+    def get_current_task_type(self):
+        """Task type which was used as current context on context reset.
+
+        Returns:
+            Union[str, None]: Task type.
+
+        """
+        if self._current_task_type is _NOT_SET:
+            task_type = None
+            task_entity = self.get_current_task_entity()
+            if task_entity:
+                task_type = task_entity["taskType"]
+            self._current_task_type = task_type
+        return self._current_task_type
+
+    def get_current_folder_entity(self):
+        """Folder entity for current context folder.
+
+        Returns:
+            Union[dict[str, Any], None]: Folder entity.
+
+        """
+        if self._current_folder_entity is not _NOT_SET:
+            return copy.deepcopy(self._current_folder_entity)
+        folder_entity = None
+        folder_path = self.get_current_folder_path()
+        if folder_path:
+            project_name = self.get_current_project_name()
+            folder_entity = ayon_api.get_folder_by_path(
+                project_name, folder_path
+            )
+        self._current_folder_entity = folder_entity
+        return copy.deepcopy(self._current_folder_entity)
+
+    def get_current_task_entity(self):
+        """Task entity for current context task.
+
+        Returns:
+            Union[dict[str, Any], None]: Task entity.
+
+        """
+        if self._current_task_entity is not _NOT_SET:
+            return copy.deepcopy(self._current_task_entity)
+        task_entity = None
+        task_name = self.get_current_task_name()
+        if task_name:
+            folder_entity = self.get_current_folder_entity()
+            if folder_entity:
+                project_name = self.get_current_project_name()
+                task_entity = ayon_api.get_task_by_name(
+                    project_name,
+                    folder_id=folder_entity["id"],
+                    task_name=task_name
+                )
+        self._current_task_entity = task_entity
+        return copy.deepcopy(self._current_task_entity)
+
+
     def get_current_workfile_path(self):
         """Workfile path which was opened on context reset.
 
@@ -1592,6 +1656,12 @@ class CreateContext:
                 self._current_project_name)
         return self._current_project_anatomy
 
+    def get_current_project_settings(self):
+        if self._current_project_settings is None:
+            self._current_project_settings = get_project_settings(
+                self.get_current_project_name())
+        return self._current_project_settings
+
     @property
     def context_has_changed(self):
         """Host context has changed.
@@ -1718,7 +1788,12 @@ class CreateContext:
         self._current_task_name = task_name
         self._current_workfile_path = workfile_path
 
+        self._current_folder_entity = _NOT_SET
+        self._current_task_entity = _NOT_SET
+        self._current_task_type = _NOT_SET
+
         self._current_project_anatomy = None
+        self._current_project_settings = None
 
     def reset_plugins(self, discover_publish_plugins=True):
         """Reload plugins.
@@ -1772,7 +1847,7 @@ class CreateContext:
 
     def _reset_creator_plugins(self):
         # Prepare settings
-        project_settings = get_project_settings(self.project_name)
+        project_settings = self.get_current_project_settings()
 
         # Discover and prepare creators
         creators = {}

client/ayon_core/pipeline/publish/lib.py

@@ -336,17 +336,16 @@ def get_plugin_settings(plugin, project_settings, log, category=None):
     settings_category = getattr(plugin, "settings_category", None)
     if settings_category:
         try:
-            return (
-                project_settings
-                [settings_category]
-                ["publish"]
-                [plugin.__name__]
-            )
+            category_settings = project_settings[settings_category]
         except KeyError:
             log.warning((
-                "Couldn't find plugin '{}' settings"
-                " under settings category '{}'"
-            ).format(plugin.__name__, settings_category))
+                "Couldn't find settings category '{}' in project settings"
+            ).format(settings_category))
+            return {}
+
+        try:
+            return category_settings["publish"][plugin.__name__]
+        except KeyError:
             return {}
 
     # Use project settings based on a category name

client/ayon_core/plugins/publish/collect_anatomy_instance_data.py

@@ -391,7 +391,11 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
             anatomy_data.update(folder_data)
             return
 
-        if instance.data.get("newAssetPublishing"):
+        if (
+            instance.data.get("newHierarchyIntegration")
+            # Backwards compatible (Deprecated since 24/06/06)
+            or instance.data.get("newAssetPublishing")
+        ):
             hierarchy = instance.data["hierarchy"]
             anatomy_data["hierarchy"] = hierarchy
 
@@ -409,7 +413,7 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
                     "path": instance.data["folderPath"],
                     # TODO get folder type from hierarchy
                     #   Using 'Shot' is current default behavior of editorial
-                    #   (or 'newAssetPublishing') publishing.
+                    #   (or 'newHierarchyIntegration') publishing.
                     "type": "Shot",
                 },
             })
@@ -432,15 +436,22 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
         if task_data:
             # Fill task data
             # - if we're in editorial, make sure the task type is filled
-            if (
-                not instance.data.get("newAssetPublishing")
-                or task_data["type"]
-            ):
+            new_hierarchy = (
+                instance.data.get("newHierarchyIntegration")
+                # Backwards compatible (Deprecated since 24/06/06)
+                or instance.data.get("newAssetPublishing")
+            )
+            if not new_hierarchy or task_data["type"]:
                 anatomy_data["task"] = task_data
                 return
 
         # New hierarchy is not created, so we can only skip rest of the logic
-        if not instance.data.get("newAssetPublishing"):
+        new_hierarchy = (
+            instance.data.get("newHierarchyIntegration")
+            # Backwards compatible (Deprecated since 24/06/06)
+            or instance.data.get("newAssetPublishing")
+        )
+        if not new_hierarchy:
             return
 
         # Try to find task data based on hierarchy context and folder path

client/ayon_core/plugins/publish/collect_scene_version.py

@@ -27,7 +27,8 @@ class CollectSceneVersion(pyblish.api.ContextPlugin):
         "nuke",
         "photoshop",
         "resolve",
-        "tvpaint"
+        "tvpaint",
+        "motionbuilder"
     ]
 
     # in some cases of headless publishing (for example webpublisher using PS)

client/ayon_core/plugins/publish/extract_color_transcode.py

@@ -364,7 +364,7 @@ class ExtractOIIOTranscode(publish.Extractor):
 
         if not repre.get("colorspaceData"):
             self.log.debug("Representation '{}' has no colorspace data. "
-                           "Skipped.")
+                           "Skipped.".format(repre["name"]))
             return False
 
         return True

client/ayon_core/plugins/publish/validate_asset_docs.py

@@ -24,7 +24,11 @@ class ValidateFolderEntities(pyblish.api.InstancePlugin):
         if instance.data.get("folderEntity"):
             self.log.debug("Instance has set fodler entity in its data.")
 
-        elif instance.data.get("newAssetPublishing"):
+        elif (
+            instance.data.get("newHierarchyIntegration")
+            # Backwards compatible (Deprecated since 24/06/06)
+            or instance.data.get("newAssetPublishing")
+        ):
             # skip if it is editorial
             self.log.debug("Editorial instance has no need to check...")
 

client/ayon_core/resources/ftrack/action_icons/ActionAskWhereIRun.svg

@@ -1,131 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 20010904//EN"
-              "http://www.w3.org/TR/2001/REC-SVG-20010904/DTD/svg10.dtd">
-
-<svg xmlns="http://www.w3.org/2000/svg"
-     width="2.93333in" height="3.06667in"
-     viewBox="0 0 512 512"
->
-  <g>
-    <linearGradient gradientUnits="userSpaceOnUse" id="SVGID_1_" x1="-0.0000027" x2="512" y1="256" y2="256">
-      <stop offset="0" style="stop-color:#541f1b"/>
-      <stop offset="1" style="stop-color:#a91b0d"/>
-    </linearGradient>
-    <circle cx="256" cy="256" fill="url(#SVGID_1_)" r="256"/>
-    <linearGradient gradientUnits="userSpaceOnUse" id="SVGID_2_" x1="42.6666641" x2="469.3333435" y1="256.0005188" y2="256.0005188">
-      <stop offset="0" style="stop-color:#a91b0d"/>
-      <stop offset="1" style="stop-color:#541f1b"/>
-    </linearGradient>
-    <path d="M256,469.3338623c-117.6314697,0-213.3333435-95.7023926-213.3333435-213.3333435    c0-117.6314545,95.7018661-213.333313,213.3333435-213.333313c117.6357422,0,213.3333435,95.7018661,213.3333435,213.333313    C469.3333435,373.6314697,373.6357422,469.3338623,256,469.3338623z" fill="url(#SVGID_2_)"/>
-  </g>
-  <g transform="
-      translate(80, 80)
-      scale(0.4)
-  ">
-    <path id="glasses"
-           fill="#000"
-           d="M 314.00,503.21
-              C 307.04,504.43 299.79,504.67 294.04,509.39
-                281.95,519.33 287.74,545.64 293.31,558.00
-                305.34,584.70 329.18,602.65 359.00,603.00
-                359.00,603.00 367.00,603.00 367.00,603.00
-                390.85,602.89 413.70,588.04 421.25,565.00
-                424.01,556.59 424.10,550.65 424.00,542.00
-                423.57,505.69 375.59,507.27 350.00,504.83
-                350.00,504.83 335.00,503.91 335.00,503.91
-                335.00,503.91 325.00,503.21 325.00,503.21
-                325.00,503.21 314.00,503.21 314.00,503.21 Z
-              M 549.00,503.42
-              C 549.00,503.42 536.00,504.09 536.00,504.09
-                536.00,504.09 492.00,508.80 492.00,508.80
-                482.54,510.63 471.18,514.25 464.32,521.30
-                457.58,528.23 455.90,537.72 456.00,547.00
-                456.35,577.84 481.12,602.64 512.00,603.00
-                540.73,603.33 565.64,594.85 581.39,569.00
-                587.72,558.59 592.85,544.28 593.00,532.00
-                593.07,525.52 593.79,518.45 589.58,513.02
-                581.71,502.84 560.89,501.98 549.00,503.42 Z" />
-    <path id="head"
-          fill="#000"
-          d="M 196.00,310.00
-             C 157.00,317.34 100.69,333.54 68.00,355.67
-               49.93,367.90 32.97,386.48 45.31,409.00
-               56.44,429.32 84.25,442.43 105.00,450.99
-               105.00,450.99 124.00,458.31 124.00,458.31
-               126.46,459.18 131.76,460.54 133.18,462.51
-               135.43,465.18 132.87,477.62 133.18,482.00
-               133.72,499.63 138.37,519.19 146.27,535.00
-               146.27,535.00 160.00,558.00 160.00,558.00
-               151.04,562.00 138.14,570.76 130.00,576.58
-               106.10,593.66 85.83,612.72 66.73,635.00
-               66.73,635.00 50.58,655.00 50.58,655.00
-               46.85,659.79 43.49,662.96 42.00,669.00
-               42.00,669.00 80.00,697.58 80.00,697.58
-               80.00,697.58 134.00,738.63 134.00,738.63
-               134.00,738.63 159.00,757.63 159.00,757.63
-               159.00,757.63 168.69,766.17 168.69,766.17
-               168.69,766.17 166.41,788.00 166.41,788.00
-               166.41,788.00 159.00,839.00 159.00,839.00
-               159.00,839.00 725.00,839.00 725.00,839.00
-               725.00,839.00 715.00,787.00 715.00,787.00
-               714.23,783.16 710.80,769.90 711.69,767.01
-               712.77,763.46 718.06,760.08 721.00,757.87
-               721.00,757.87 746.00,738.87 746.00,738.87
-               746.00,738.87 805.00,693.88 805.00,693.88
-               805.00,693.88 839.00,668.00 839.00,668.00
-               830.81,653.76 810.68,631.16 799.04,619.00
-               779.93,599.05 746.32,568.97 721.00,558.00
-               736.80,531.67 747.05,511.60 746.88,480.00
-               746.99,476.23 745.11,464.71 746.88,462.51
-               748.19,460.62 752.74,459.42 755.00,458.67
-               755.00,458.67 773.00,451.99 773.00,451.99
-               789.48,445.21 809.73,435.70 823.00,423.83
-               833.14,414.76 839.34,405.89 838.99,392.00
-               838.62,377.75 825.69,365.33 815.00,357.38
-               791.37,339.79 750.60,326.38 722.00,318.42
-               722.00,318.42 698.00,312.65 698.00,312.65
-               694.98,311.97 689.62,311.22 687.31,309.28
-               684.49,306.90 682.00,295.04 680.86,291.00
-               680.86,291.00 667.37,242.00 667.37,242.00
-               655.66,196.99 634.72,129.32 611.40,90.00
-               599.32,69.64 582.92,49.09 559.00,42.75
-               551.96,40.89 546.17,40.92 539.00,41.00
-               521.02,41.21 499.67,47.67 482.00,51.58
-               468.77,54.50 455.47,55.86 442.00,56.82
-               442.00,56.82 432.00,56.04 432.00,56.04
-               400.44,54.66 371.26,41.33 343.00,41.00
-               335.69,40.92 330.19,40.64 323.00,42.48
-               298.44,48.76 281.88,68.37 268.95,89.00
-               244.31,128.34 223.03,195.41 211.63,241.00
-               211.63,241.00 199.63,288.00 199.63,288.00
-               198.01,294.48 194.47,303.56 196.00,310.00 Z
-             M 687.00,478.00
-             C 686.85,494.73 678.57,518.97 665.00,529.32
-               658.84,534.01 657.01,532.67 651.00,535.35
-               644.22,538.36 638.88,543.45 635.40,550.00
-               635.40,550.00 622.40,582.00 622.40,582.00
-               622.40,582.00 611.14,608.00 611.14,608.00
-               592.73,649.33 562.84,703.15 531.00,735.00
-               531.00,735.00 518.00,747.71 518.00,747.71
-               499.32,763.96 471.29,778.70 446.00,779.00
-               399.64,779.54 368.31,757.20 338.87,723.00
-               298.68,676.31 271.17,614.00 248.94,557.00
-               245.41,547.94 240.81,540.99 232.00,536.33
-               224.56,532.38 222.45,534.62 215.00,528.53
-               201.42,517.45 194.00,495.06 194.00,478.00
-               194.00,478.00 226.00,483.92 226.00,483.92
-               226.00,483.92 305.00,494.83 305.00,494.83
-               305.00,494.83 350.00,498.09 350.00,498.09
-               350.00,498.09 391.00,500.00 391.00,500.00
-               391.00,500.00 408.00,501.00 408.00,501.00
-               408.00,501.00 473.00,501.00 473.00,501.00
-               473.00,501.00 485.00,500.04 485.00,500.04
-               485.00,500.04 501.00,500.04 501.00,500.04
-               501.00,500.04 520.00,499.00 520.00,499.00
-               520.00,499.00 531.00,498.04 531.00,498.04
-               559.97,496.78 589.26,493.87 618.00,489.73
-               618.00,489.73 662.00,482.58 662.00,482.58
-               662.00,482.58 687.00,478.00 687.00,478.00 Z"
-    />
-  </g>
-</svg>

client/ayon_core/resources/ftrack/action_icons/AssetsRemover.svg

@@ -1 +0,0 @@
-<?xml version="1.0" ?><svg enable-background="new 0 0 512 512" id="Layer_1" version="1.1" viewBox="0 0 512 512" xml:space="preserve" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"><g><g><linearGradient gradientUnits="userSpaceOnUse" id="SVGID_1_" x1="-0.0000027" x2="512" y1="256" y2="256"><stop offset="0" style="stop-color:#00AEEE"/><stop offset="1" style="stop-color:#0095DA"/></linearGradient><circle cx="256" cy="256" fill="url(#SVGID_1_)" r="256"/><linearGradient gradientUnits="userSpaceOnUse" id="SVGID_2_" x1="42.6666641" x2="469.3333435" y1="256.0005188" y2="256.0005188"><stop offset="0" style="stop-color:#0095DA"/><stop offset="1" style="stop-color:#00AEEE"/></linearGradient><path d="M256,469.3338623c-117.6314697,0-213.3333435-95.7023926-213.3333435-213.3333435    c0-117.6314545,95.7018661-213.333313,213.3333435-213.333313c117.6357422,0,213.3333435,95.7018661,213.3333435,213.333313    C469.3333435,373.6314697,373.6357422,469.3338623,256,469.3338623z" fill="url(#SVGID_2_)"/></g><g><path d="M315.8906555,167.4933319h-28.3743896C287.5162659,154.4944,277.020813,144,264.0218811,144    c-13.0010834,0-23.4944153,10.4944-23.4944153,23.4933319h-28.3760071v40.6847992h103.7391968V167.4933319z" opacity="0.3"/><path d="M325.8906555,187.4895935v30.6885376H202.1504059v-30.6885376H164.354126V384h199.2911987V187.4895935    H325.8906555z M309.4405212,336.4693298l-7.0703735,7.0698853l-38.3712158-38.3712158l-38.3717346,38.3712158    l-7.0704041-7.0698853l38.3717346-38.3717346l-38.3717346-38.3717346l7.0704041-7.0698547l38.3717346,38.3711853    l38.3712158-38.3711853l7.0703735,7.0698547l-38.3717346,38.3717346L309.4405212,336.4693298z" opacity="0.3"/></g><g><path d="M307.8906555,159.4933319h-28.3743896C279.5162659,146.4944,269.020813,136,256.0218811,136    c-13.0010834,0-23.4944153,10.4944-23.4944153,23.4933319h-28.3760071v40.6847992h103.7391968V159.4933319z" fill="#FFFFFF"/><path d="M317.8906555,179.4895935v30.6885376H194.1504059v-30.6885376H156.354126V376h199.2911987V179.4895935    H317.8906555z M301.4405212,328.4693298l-7.0703735,7.0698853l-38.3712158-38.3712158l-38.3717346,38.3712158    l-7.0704041-7.0698853l38.3717346-38.3717346l-38.3717346-38.3717346l7.0704041-7.0698547l38.3717346,38.3711853    l38.3712158-38.3711853l7.0703735,7.0698547l-38.3717346,38.3717346L301.4405212,328.4693298z" fill="#FFFFFF"/></g></g></svg>

client/ayon_core/resources/ftrack/sign_in_message.html

@@ -1,32 +0,0 @@
-<html>
-    <style type="text/css">
-        body {
-            background-color: #333;
-            text-align: center;
-            color: #ccc;
-            margin-top: 200px;
-        }
-        h1 {
-            font-family: "DejaVu Sans";
-            font-size: 36px;
-            margin: 20px 0;
-        }
-        h3 {
-            font-weight: normal;
-            font-family: "DejaVu Sans";
-            margin: 30px 10px;
-        }
-        em {
-            color: #fff;
-        }
-    </style>
-    <body>
-        <h1>Sign in to Ftrack was successful</h1>
-        <h3>
-            You signed in with username <em>{}</em>.
-        </h3>
-        <h3>
-            You can close this window now.
-        </h3>
-    </body>
-</html>

client/ayon_core/tools/adobe_webserver/readme.txt

@@ -1,12 +0,0 @@
-Adobe webserver
----------------
-Aiohttp (Asyncio) based websocket server used for communication with host
-applications, currently only for Adobe (but could be used for any non python
-DCC which has websocket client).
-
-This webserver is started in spawned Python process that opens DCC during
-its launch, waits for connection from DCC and handles communication going
-forward. Server is closed before Python process is killed.
-
-(Different from `ayon_core/modules/webserver` as that one is running in Tray,
-this one is running in spawn Python process.)

client/ayon_core/tools/launcher/ui/hierarchy_page.py

@@ -70,7 +70,7 @@ class HierarchyPage(QtWidgets.QWidget):
         main_layout.addWidget(content_body, 1)
 
         btn_back.clicked.connect(self._on_back_clicked)
-        refresh_btn.clicked.connect(self._on_refreh_clicked)
+        refresh_btn.clicked.connect(self._on_refresh_clicked)
         folders_filter_text.textChanged.connect(self._on_filter_text_changed)
 
         self._is_visible = False
@@ -99,7 +99,7 @@ class HierarchyPage(QtWidgets.QWidget):
     def _on_back_clicked(self):
         self._controller.set_selected_project(None)
 
-    def _on_refreh_clicked(self):
+    def _on_refresh_clicked(self):
         self._controller.refresh()
 
     def _on_filter_text_changed(self, text):

client/ayon_core/tools/loader/abstract.py

@@ -172,12 +172,30 @@ class VersionItem:
     def __gt__(self, other):
         if not isinstance(other, VersionItem):
             return False
-        if (
-            other.version == self.version
-            and self.is_hero
-        ):
+        # Make sure hero versions are positive
+        version = abs(self.version)
+        other_version = abs(other.version)
+        # Hero version is greater than non-hero
+        if version == other_version:
+            return self.is_hero
+        return version > other_version
+
+    def __lt__(self, other):
+        if not isinstance(other, VersionItem):
             return True
-        return other.version < self.version
+        # Make sure hero versions are positive
+        version = abs(self.version)
+        other_version = abs(other.version)
+        # Non-hero version is lesser than hero
+        if version == other_version:
+            return not self.is_hero
+        return version < other_version
+
+    def __ge__(self, other):
+        return self.__eq__(other) or self.__gt__(other)
+
+    def __le__(self, other):
+        return self.__eq__(other) or self.__lt__(other)
 
     def to_data(self):
         return {

client/ayon_core/tools/loader/control.py

@@ -348,10 +348,18 @@ class LoaderController(BackendLoaderController, FrontendLoaderController):
             return set()
 
         if not self._loaded_products_cache.is_valid:
-            if isinstance(self._host, ILoadHost):
-                containers = self._host.get_containers()
-            else:
-                containers = self._host.ls()
+            try:
+                if isinstance(self._host, ILoadHost):
+                    containers = self._host.get_containers()
+                else:
+                    containers = self._host.ls()
+
+            except BaseException:
+                self.log.error(
+                    "Failed to collect loaded products.", exc_info=True
+                )
+                containers = []
+
             repre_ids = set()
             for container in containers:
                 repre_id = container.get("representation")

client/ayon_core/tools/loader/ui/folders_widget.py

@@ -321,6 +321,8 @@ class LoaderFoldersWidget(QtWidgets.QWidget):
         """
 
         self._folders_proxy_model.setFilterFixedString(name)
+        if name:
+            self._folders_view.expandAll()
 
     def set_merged_products_selection(self, items):
         """

client/ayon_core/tools/loader/ui/products_model.py

@@ -199,7 +199,9 @@ class ProductsModel(QtGui.QStandardItemModel):
             product_item = self._product_items_by_id.get(product_id)
             if product_item is None:
                 return None
-            return list(product_item.version_items.values())
+            product_items = list(product_item.version_items.values())
+            product_items.sort(reverse=True)
+            return product_items
 
         if role == QtCore.Qt.EditRole:
             return None

client/ayon_core/tools/publisher/control.py

@@ -8,6 +8,7 @@ import tempfile
 import shutil
 import inspect
 from abc import ABCMeta, abstractmethod
+import re
 
 import six
 import arrow
@@ -39,6 +40,7 @@ from ayon_core.pipeline.create.context import (
 )
 from ayon_core.pipeline.publish import get_publish_instance_label
 from ayon_core.tools.common_models import HierarchyModel
+from ayon_core.lib.profiles_filtering import filter_profiles
 
 # Define constant for plugin orders offset
 PLUGIN_ORDER_OFFSET = 0.5
@@ -1686,6 +1688,15 @@ class PublisherController(BasePublisherController):
         """Publish plugins."""
         return self._create_context.publish_plugins
 
+    def _get_current_project_settings(self):
+        """Current project settings.
+
+        Returns:
+            dict
+        """
+
+        return self._create_context.get_current_project_settings()
+
     # Hierarchy model
     def get_folder_items(self, project_name, sender=None):
         return self._hierarchy_model.get_folder_items(project_name, sender)
@@ -1827,8 +1838,13 @@ class PublisherController(BasePublisherController):
     def _collect_creator_items(self):
         # TODO add crashed initialization of create plugins to report
         output = {}
+        allowed_creator_pattern = self._get_allowed_creators_pattern()
         for identifier, creator in self._create_context.creators.items():
             try:
+                if (not self._is_label_allowed(
+                        creator.label, allowed_creator_pattern)):
+                    self.log.debug(f"{creator.label} not allowed for context")
+                    continue
                 output[identifier] = CreatorItem.from_creator(creator)
             except Exception:
                 self.log.error(
@@ -1839,6 +1855,60 @@ class PublisherController(BasePublisherController):
 
         return output
 
+    def _get_allowed_creators_pattern(self):
+        """Provide regex pattern for configured creator labels in this context
+
+        If no profile matches current context, it shows all creators.
+        Support usage of regular expressions for configured values.
+        Returns:
+            (re.Pattern)[optional]: None or regex compiled patterns
+                into single one ('Render|Image.*')
+        """
+
+        task_type = self._create_context.get_current_task_type()
+        project_settings = self._get_current_project_settings()
+
+        filter_creator_profiles = (
+            project_settings
+            ["core"]
+            ["tools"]
+            ["creator"]
+            ["filter_creator_profiles"]
+        )
+        filtering_criteria = {
+            "task_names": self.current_task_name,
+            "task_types": task_type,
+            "host_names": self._create_context.host_name
+        }
+        profile = filter_profiles(
+            filter_creator_profiles,
+            filtering_criteria,
+            logger=self.log
+        )
+
+        allowed_creator_pattern = None
+        if profile:
+            allowed_creator_labels = {
+                label
+                for label in profile["creator_labels"]
+                if label
+            }
+            self.log.debug(f"Only allowed `{allowed_creator_labels}` creators")
+            allowed_creator_pattern = (
+                re.compile("|".join(allowed_creator_labels)))
+        return allowed_creator_pattern
+
+    def _is_label_allowed(self, label, allowed_labels_regex):
+        """Implement regex support for allowed labels.
+
+        Args:
+            label (str): Label of creator - shown in Publisher
+            allowed_labels_regex (re.Pattern): compiled regular expression
+        """
+        if not allowed_labels_regex:
+            return True
+        return bool(allowed_labels_regex.match(label))
+
     def _reset_instances(self):
         """Reset create instances."""
         if self._resetting_instances:

client/ayon_core/tools/stdout_broker/__init__.py

@@ -0,0 +1,5 @@
+from .broker import StdOutBroker
+
+__all__ = (
+    "StdOutBroker",
+)

client/ayon_core/tools/stdout_broker/app.py

@@ -1,173 +1,12 @@
-import os
-import sys
-import threading
-import collections
-import websocket
-import json
-from datetime import datetime
+import warnings
+from .broker import StdOutBroker
 
-from ayon_core.lib import Logger
-from openpype_modules.webserver.host_console_listener import MsgAction
+warnings.warn(
+    (
+        "Import of 'StdOutBroker' from 'ayon_core.tools.stdout_broker.app'"
+        " is deprecated. Please use 'ayon_core.tools.stdout_broker' instead."
+    ),
+    DeprecationWarning
+)
 
-log = Logger.get_logger(__name__)
-
-
-class StdOutBroker:
-    """
-    Application showing console in Services tray for non python hosts
-    instead of cmd window.
-    """
-    MAX_LINES = 10000
-    TIMER_TIMEOUT = 0.200
-
-    def __init__(self, host_name):
-        self.host_name = host_name
-        self.webserver_client = None
-
-        self.original_stdout_write = None
-        self.original_stderr_write = None
-        self.log_queue = collections.deque()
-
-        date_str = datetime.now().strftime("%d%m%Y%H%M%S")
-        self.host_id = "{}_{}".format(self.host_name, date_str)
-
-        self._std_available = False
-        self._is_running = False
-        self._catch_std_outputs()
-
-        self._timer = None
-
-    @property
-    def send_to_tray(self):
-        """Checks if connected to tray and have access to logs."""
-        return self.webserver_client and self._std_available
-
-    def start(self):
-        """Start app, create and start timer"""
-        if not self._std_available or self._is_running:
-            return
-        self._is_running = True
-        self._create_timer()
-        self._connect_to_tray()
-
-    def stop(self):
-        """Disconnect from Tray, process last logs"""
-        if not self._is_running:
-            return
-        self._is_running = False
-        self._process_queue()
-        self._disconnect_from_tray()
-
-    def host_connected(self):
-        """Send to Tray console that host is ready - icon change. """
-        log.info("Host {} connected".format(self.host_id))
-
-        payload = {
-            "host": self.host_id,
-            "action": MsgAction.INITIALIZED,
-            "text": "Integration with {}".format(
-                str.capitalize(self.host_name))
-        }
-        self._send(payload)
-
-    def _create_timer(self):
-        timer = threading.Timer(self.TIMER_TIMEOUT, self._timer_callback)
-        timer.start()
-        self._timer = timer
-
-    def _timer_callback(self):
-        if not self._is_running:
-            return
-        self._process_queue()
-        self._create_timer()
-
-    def _connect_to_tray(self):
-        """Connect to Tray webserver to pass console output. """
-        if not self._std_available:  # not content to log
-            return
-        ws = websocket.WebSocket()
-        webserver_url = os.environ.get("AYON_WEBSERVER_URL")
-
-        if not webserver_url:
-            print("Unknown webserver url, cannot connect to pass log")
-            return
-
-        webserver_url = webserver_url.replace("http", "ws")
-        ws.connect("{}/ws/host_listener".format(webserver_url))
-        self.webserver_client = ws
-
-        payload = {
-            "host": self.host_id,
-            "action": MsgAction.CONNECTING,
-            "text": "Integration with {}".format(
-                str.capitalize(self.host_name))
-        }
-        self._send(payload)
-
-    def _disconnect_from_tray(self):
-        """Send to Tray that host is closing - remove from Services. """
-        print("Host {} closing".format(self.host_name))
-        if not self.webserver_client:
-            return
-
-        payload = {
-            "host": self.host_id,
-            "action": MsgAction.CLOSE,
-            "text": "Integration with {}".format(
-                str.capitalize(self.host_name))
-        }
-
-        self._send(payload)
-        self.webserver_client.close()
-
-    def _catch_std_outputs(self):
-        """Redirects standard out and error to own functions"""
-        if sys.stdout:
-            self.original_stdout_write = sys.stdout.write
-            sys.stdout.write = self._my_stdout_write
-            self._std_available = True
-
-        if sys.stderr:
-            self.original_stderr_write = sys.stderr.write
-            sys.stderr.write = self._my_stderr_write
-            self._std_available = True
-
-    def _my_stdout_write(self, text):
-        """Appends outputted text to queue, keep writing to original stdout"""
-        if self.original_stdout_write is not None:
-            self.original_stdout_write(text)
-        if self.send_to_tray:
-            self.log_queue.append(text)
-
-    def _my_stderr_write(self, text):
-        """Appends outputted text to queue, keep writing to original stderr"""
-        if self.original_stderr_write is not None:
-            self.original_stderr_write(text)
-        if self.send_to_tray:
-            self.log_queue.append(text)
-
-    def _process_queue(self):
-        """Sends lines and purges queue"""
-        if not self.send_to_tray:
-            return
-
-        lines = tuple(self.log_queue)
-        self.log_queue.clear()
-        if lines:
-            payload = {
-                "host": self.host_id,
-                "action": MsgAction.ADD,
-                "text": "\n".join(lines)
-            }
-
-            self._send(payload)
-
-    def _send(self, payload):
-        """Worker method to send to existing websocket connection."""
-        if not self.send_to_tray:
-            return
-
-        try:
-            self.webserver_client.send(json.dumps(payload))
-        except ConnectionResetError:  # Tray closed
-            self._connect_to_tray()
+__all__ = ("StdOutBroker", )

client/ayon_core/tools/stdout_broker/broker.py

@@ -0,0 +1,174 @@
+import os
+import sys
+import threading
+import collections
+import json
+from datetime import datetime
+
+import websocket
+
+from ayon_core.lib import Logger
+from ayon_core.modules.webserver import HostMsgAction
+
+log = Logger.get_logger(__name__)
+
+
+class StdOutBroker:
+    """
+    Application showing console in Services tray for non python hosts
+    instead of cmd window.
+    """
+    MAX_LINES = 10000
+    TIMER_TIMEOUT = 0.200
+
+    def __init__(self, host_name):
+        self.host_name = host_name
+        self.webserver_client = None
+
+        self.original_stdout_write = None
+        self.original_stderr_write = None
+        self.log_queue = collections.deque()
+
+        date_str = datetime.now().strftime("%d%m%Y%H%M%S")
+        self.host_id = "{}_{}".format(self.host_name, date_str)
+
+        self._std_available = False
+        self._is_running = False
+        self._catch_std_outputs()
+
+        self._timer = None
+
+    @property
+    def send_to_tray(self):
+        """Checks if connected to tray and have access to logs."""
+        return self.webserver_client and self._std_available
+
+    def start(self):
+        """Start app, create and start timer"""
+        if not self._std_available or self._is_running:
+            return
+        self._is_running = True
+        self._create_timer()
+        self._connect_to_tray()
+
+    def stop(self):
+        """Disconnect from Tray, process last logs"""
+        if not self._is_running:
+            return
+        self._is_running = False
+        self._process_queue()
+        self._disconnect_from_tray()
+
+    def host_connected(self):
+        """Send to Tray console that host is ready - icon change. """
+        log.info("Host {} connected".format(self.host_id))
+
+        payload = {
+            "host": self.host_id,
+            "action": HostMsgAction.INITIALIZED,
+            "text": "Integration with {}".format(
+                str.capitalize(self.host_name))
+        }
+        self._send(payload)
+
+    def _create_timer(self):
+        timer = threading.Timer(self.TIMER_TIMEOUT, self._timer_callback)
+        timer.start()
+        self._timer = timer
+
+    def _timer_callback(self):
+        if not self._is_running:
+            return
+        self._process_queue()
+        self._create_timer()
+
+    def _connect_to_tray(self):
+        """Connect to Tray webserver to pass console output. """
+        if not self._std_available:  # not content to log
+            return
+        ws = websocket.WebSocket()
+        webserver_url = os.environ.get("AYON_WEBSERVER_URL")
+
+        if not webserver_url:
+            print("Unknown webserver url, cannot connect to pass log")
+            return
+
+        webserver_url = webserver_url.replace("http", "ws")
+        ws.connect("{}/ws/host_listener".format(webserver_url))
+        self.webserver_client = ws
+
+        payload = {
+            "host": self.host_id,
+            "action": HostMsgAction.CONNECTING,
+            "text": "Integration with {}".format(
+                str.capitalize(self.host_name))
+        }
+        self._send(payload)
+
+    def _disconnect_from_tray(self):
+        """Send to Tray that host is closing - remove from Services. """
+        print("Host {} closing".format(self.host_name))
+        if not self.webserver_client:
+            return
+
+        payload = {
+            "host": self.host_id,
+            "action": HostMsgAction.CLOSE,
+            "text": "Integration with {}".format(
+                str.capitalize(self.host_name))
+        }
+
+        self._send(payload)
+        self.webserver_client.close()
+
+    def _catch_std_outputs(self):
+        """Redirects standard out and error to own functions"""
+        if sys.stdout:
+            self.original_stdout_write = sys.stdout.write
+            sys.stdout.write = self._my_stdout_write
+            self._std_available = True
+
+        if sys.stderr:
+            self.original_stderr_write = sys.stderr.write
+            sys.stderr.write = self._my_stderr_write
+            self._std_available = True
+
+    def _my_stdout_write(self, text):
+        """Appends outputted text to queue, keep writing to original stdout"""
+        if self.original_stdout_write is not None:
+            self.original_stdout_write(text)
+        if self.send_to_tray:
+            self.log_queue.append(text)
+
+    def _my_stderr_write(self, text):
+        """Appends outputted text to queue, keep writing to original stderr"""
+        if self.original_stderr_write is not None:
+            self.original_stderr_write(text)
+        if self.send_to_tray:
+            self.log_queue.append(text)
+
+    def _process_queue(self):
+        """Sends lines and purges queue"""
+        if not self.send_to_tray:
+            return
+
+        lines = tuple(self.log_queue)
+        self.log_queue.clear()
+        if lines:
+            payload = {
+                "host": self.host_id,
+                "action": HostMsgAction.ADD,
+                "text": "\n".join(lines)
+            }
+
+            self._send(payload)
+
+    def _send(self, payload):
+        """Worker method to send to existing websocket connection."""
+        if not self.send_to_tray:
+            return
+
+        try:
+            self.webserver_client.send(json.dumps(payload))
+        except ConnectionResetError:  # Tray closed
+            self._connect_to_tray()

client/ayon_core/tools/tray/tray.py

@@ -447,8 +447,10 @@ class SystemTrayIcon(QtWidgets.QSystemTrayIcon):
 
     def initialize_addons(self):
         self._initializing_addons = True
-        self.tray_man.initialize_addons()
-        self._initializing_addons = False
+        try:
+            self.tray_man.initialize_addons()
+        finally:
+            self._initializing_addons = False
 
     def _click_timer_timeout(self):
         self._click_timer.stop()

client/ayon_core/tools/utils/folders_widget.py

@@ -370,6 +370,8 @@ class FoldersWidget(QtWidgets.QWidget):
         """
 
         self._folders_proxy_model.setFilterFixedString(name)
+        if name:
+            self._folders_view.expandAll()
 
     def refresh(self):
         """Refresh folders model.

client/ayon_core/vendor/python/python_2/README.md

@@ -1,3 +0,0 @@
-## Info
-
-Only **Python 2** specific modules are here.

client/ayon_core/vendor/python/python_2/arrow/__init__.py

@@ -1,18 +0,0 @@
-# -*- coding: utf-8 -*-
-from ._version import __version__
-from .api import get, now, utcnow
-from .arrow import Arrow
-from .factory import ArrowFactory
-from .formatter import (
-    FORMAT_ATOM,
-    FORMAT_COOKIE,
-    FORMAT_RFC822,
-    FORMAT_RFC850,
-    FORMAT_RFC1036,
-    FORMAT_RFC1123,
-    FORMAT_RFC2822,
-    FORMAT_RFC3339,
-    FORMAT_RSS,
-    FORMAT_W3C,
-)
-from .parser import ParserError

client/ayon_core/vendor/python/python_2/arrow/_version.py

@@ -1 +0,0 @@
-__version__ = "0.17.0"

client/ayon_core/vendor/python/python_2/arrow/api.py

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Provides the default implementation of :class:`ArrowFactory <arrow.factory.ArrowFactory>`
-methods for use as a module API.
-
-"""
-
-from __future__ import absolute_import
-
-from arrow.factory import ArrowFactory
-
-# internal default factory.
-_factory = ArrowFactory()
-
-
-def get(*args, **kwargs):
-    """Calls the default :class:`ArrowFactory <arrow.factory.ArrowFactory>` ``get`` method."""
-
-    return _factory.get(*args, **kwargs)
-
-
-get.__doc__ = _factory.get.__doc__
-
-
-def utcnow():
-    """Calls the default :class:`ArrowFactory <arrow.factory.ArrowFactory>` ``utcnow`` method."""
-
-    return _factory.utcnow()
-
-
-utcnow.__doc__ = _factory.utcnow.__doc__
-
-
-def now(tz=None):
-    """Calls the default :class:`ArrowFactory <arrow.factory.ArrowFactory>` ``now`` method."""
-
-    return _factory.now(tz)
-
-
-now.__doc__ = _factory.now.__doc__
-
-
-def factory(type):
-    """Returns an :class:`.ArrowFactory` for the specified :class:`Arrow <arrow.arrow.Arrow>`
-    or derived type.
-
-    :param type: the type, :class:`Arrow <arrow.arrow.Arrow>` or derived.
-
-    """
-
-    return ArrowFactory(type)
-
-
-__all__ = ["get", "utcnow", "now", "factory"]

client/ayon_core/vendor/python/python_2/arrow/constants.py

@@ -1,9 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Output of time.mktime(datetime.max.timetuple()) on macOS
-# This value must be hardcoded for compatibility with Windows
-# Platform-independent max timestamps are hard to form
-# https://stackoverflow.com/q/46133223
-MAX_TIMESTAMP = 253402318799.0
-MAX_TIMESTAMP_MS = MAX_TIMESTAMP * 1000
-MAX_TIMESTAMP_US = MAX_TIMESTAMP * 1000000

client/ayon_core/vendor/python/python_2/arrow/factory.py

@@ -1,301 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Implements the :class:`ArrowFactory <arrow.factory.ArrowFactory>` class,
-providing factory methods for common :class:`Arrow <arrow.arrow.Arrow>`
-construction scenarios.
-
-"""
-
-from __future__ import absolute_import
-
-import calendar
-from datetime import date, datetime
-from datetime import tzinfo as dt_tzinfo
-from time import struct_time
-
-from dateutil import tz as dateutil_tz
-
-from arrow import parser
-from arrow.arrow import Arrow
-from arrow.util import is_timestamp, iso_to_gregorian, isstr
-
-
-class ArrowFactory(object):
-    """A factory for generating :class:`Arrow <arrow.arrow.Arrow>` objects.
-
-    :param type: (optional) the :class:`Arrow <arrow.arrow.Arrow>`-based class to construct from.
-        Defaults to :class:`Arrow <arrow.arrow.Arrow>`.
-
-    """
-
-    def __init__(self, type=Arrow):
-        self.type = type
-
-    def get(self, *args, **kwargs):
-        """Returns an :class:`Arrow <arrow.arrow.Arrow>` object based on flexible inputs.
-
-        :param locale: (optional) a ``str`` specifying a locale for the parser. Defaults to 'en_us'.
-        :param tzinfo: (optional) a :ref:`timezone expression <tz-expr>` or tzinfo object.
-            Replaces the timezone unless using an input form that is explicitly UTC or specifies
-            the timezone in a positional argument. Defaults to UTC.
-        :param normalize_whitespace: (optional) a ``bool`` specifying whether or not to normalize
-            redundant whitespace (spaces, tabs, and newlines) in a datetime string before parsing.
-            Defaults to false.
-
-        Usage::
-
-            >>> import arrow
-
-        **No inputs** to get current UTC time::
-
-            >>> arrow.get()
-            <Arrow [2013-05-08T05:51:43.316458+00:00]>
-
-        **None** to also get current UTC time::
-
-            >>> arrow.get(None)
-            <Arrow [2013-05-08T05:51:49.016458+00:00]>
-
-        **One** :class:`Arrow <arrow.arrow.Arrow>` object, to get a copy.
-
-            >>> arw = arrow.utcnow()
-            >>> arrow.get(arw)
-            <Arrow [2013-10-23T15:21:54.354846+00:00]>
-
-        **One** ``float`` or ``int``, convertible to a floating-point timestamp, to get
-        that timestamp in UTC::
-
-            >>> arrow.get(1367992474.293378)
-            <Arrow [2013-05-08T05:54:34.293378+00:00]>
-
-            >>> arrow.get(1367992474)
-            <Arrow [2013-05-08T05:54:34+00:00]>
-
-        **One** ISO 8601-formatted ``str``, to parse it::
-
-            >>> arrow.get('2013-09-29T01:26:43.830580')
-            <Arrow [2013-09-29T01:26:43.830580+00:00]>
-
-        **One** ISO 8601-formatted ``str``, in basic format, to parse it::
-
-            >>> arrow.get('20160413T133656.456289')
-            <Arrow [2016-04-13T13:36:56.456289+00:00]>
-
-        **One** ``tzinfo``, to get the current time **converted** to that timezone::
-
-            >>> arrow.get(tz.tzlocal())
-            <Arrow [2013-05-07T22:57:28.484717-07:00]>
-
-        **One** naive ``datetime``, to get that datetime in UTC::
-
-            >>> arrow.get(datetime(2013, 5, 5))
-            <Arrow [2013-05-05T00:00:00+00:00]>
-
-        **One** aware ``datetime``, to get that datetime::
-
-            >>> arrow.get(datetime(2013, 5, 5, tzinfo=tz.tzlocal()))
-            <Arrow [2013-05-05T00:00:00-07:00]>
-
-        **One** naive ``date``, to get that date in UTC::
-
-            >>> arrow.get(date(2013, 5, 5))
-            <Arrow [2013-05-05T00:00:00+00:00]>
-
-        **One** time.struct time::
-
-            >>> arrow.get(gmtime(0))
-            <Arrow [1970-01-01T00:00:00+00:00]>
-
-        **One** iso calendar ``tuple``, to get that week date in UTC::
-
-            >>> arrow.get((2013, 18, 7))
-            <Arrow [2013-05-05T00:00:00+00:00]>
-
-        **Two** arguments, a naive or aware ``datetime``, and a replacement
-        :ref:`timezone expression <tz-expr>`::
-
-            >>> arrow.get(datetime(2013, 5, 5), 'US/Pacific')
-            <Arrow [2013-05-05T00:00:00-07:00]>
-
-        **Two** arguments, a naive ``date``, and a replacement
-        :ref:`timezone expression <tz-expr>`::
-
-            >>> arrow.get(date(2013, 5, 5), 'US/Pacific')
-            <Arrow [2013-05-05T00:00:00-07:00]>
-
-        **Two** arguments, both ``str``, to parse the first according to the format of the second::
-
-            >>> arrow.get('2013-05-05 12:30:45 America/Chicago', 'YYYY-MM-DD HH:mm:ss ZZZ')
-            <Arrow [2013-05-05T12:30:45-05:00]>
-
-        **Two** arguments, first a ``str`` to parse and second a ``list`` of formats to try::
-
-            >>> arrow.get('2013-05-05 12:30:45', ['MM/DD/YYYY', 'YYYY-MM-DD HH:mm:ss'])
-            <Arrow [2013-05-05T12:30:45+00:00]>
-
-        **Three or more** arguments, as for the constructor of a ``datetime``::
-
-            >>> arrow.get(2013, 5, 5, 12, 30, 45)
-            <Arrow [2013-05-05T12:30:45+00:00]>
-
-        """
-
-        arg_count = len(args)
-        locale = kwargs.pop("locale", "en_us")
-        tz = kwargs.get("tzinfo", None)
-        normalize_whitespace = kwargs.pop("normalize_whitespace", False)
-
-        # if kwargs given, send to constructor unless only tzinfo provided
-        if len(kwargs) > 1:
-            arg_count = 3
-
-        # tzinfo kwarg is not provided
-        if len(kwargs) == 1 and tz is None:
-            arg_count = 3
-
-        # () -> now, @ utc.
-        if arg_count == 0:
-            if isstr(tz):
-                tz = parser.TzinfoParser.parse(tz)
-                return self.type.now(tz)
-
-            if isinstance(tz, dt_tzinfo):
-                return self.type.now(tz)
-
-            return self.type.utcnow()
-
-        if arg_count == 1:
-            arg = args[0]
-
-            # (None) -> now, @ utc.
-            if arg is None:
-                return self.type.utcnow()
-
-            # try (int, float) -> from timestamp with tz
-            elif not isstr(arg) and is_timestamp(arg):
-                if tz is None:
-                    # set to UTC by default
-                    tz = dateutil_tz.tzutc()
-                return self.type.fromtimestamp(arg, tzinfo=tz)
-
-            # (Arrow) -> from the object's datetime.
-            elif isinstance(arg, Arrow):
-                return self.type.fromdatetime(arg.datetime)
-
-            # (datetime) -> from datetime.
-            elif isinstance(arg, datetime):
-                return self.type.fromdatetime(arg)
-
-            # (date) -> from date.
-            elif isinstance(arg, date):
-                return self.type.fromdate(arg)
-
-            # (tzinfo) -> now, @ tzinfo.
-            elif isinstance(arg, dt_tzinfo):
-                return self.type.now(arg)
-
-            # (str) -> parse.
-            elif isstr(arg):
-                dt = parser.DateTimeParser(locale).parse_iso(arg, normalize_whitespace)
-                return self.type.fromdatetime(dt, tz)
-
-            # (struct_time) -> from struct_time
-            elif isinstance(arg, struct_time):
-                return self.type.utcfromtimestamp(calendar.timegm(arg))
-
-            # (iso calendar) -> convert then from date
-            elif isinstance(arg, tuple) and len(arg) == 3:
-                dt = iso_to_gregorian(*arg)
-                return self.type.fromdate(dt)
-
-            else:
-                raise TypeError(
-                    "Can't parse single argument of type '{}'".format(type(arg))
-                )
-
-        elif arg_count == 2:
-
-            arg_1, arg_2 = args[0], args[1]
-
-            if isinstance(arg_1, datetime):
-
-                # (datetime, tzinfo/str) -> fromdatetime replace tzinfo.
-                if isinstance(arg_2, dt_tzinfo) or isstr(arg_2):
-                    return self.type.fromdatetime(arg_1, arg_2)
-                else:
-                    raise TypeError(
-                        "Can't parse two arguments of types 'datetime', '{}'".format(
-                            type(arg_2)
-                        )
-                    )
-
-            elif isinstance(arg_1, date):
-
-                # (date, tzinfo/str) -> fromdate replace tzinfo.
-                if isinstance(arg_2, dt_tzinfo) or isstr(arg_2):
-                    return self.type.fromdate(arg_1, tzinfo=arg_2)
-                else:
-                    raise TypeError(
-                        "Can't parse two arguments of types 'date', '{}'".format(
-                            type(arg_2)
-                        )
-                    )
-
-            # (str, format) -> parse.
-            elif isstr(arg_1) and (isstr(arg_2) or isinstance(arg_2, list)):
-                dt = parser.DateTimeParser(locale).parse(
-                    args[0], args[1], normalize_whitespace
-                )
-                return self.type.fromdatetime(dt, tzinfo=tz)
-
-            else:
-                raise TypeError(
-                    "Can't parse two arguments of types '{}' and '{}'".format(
-                        type(arg_1), type(arg_2)
-                    )
-                )
-
-        # 3+ args -> datetime-like via constructor.
-        else:
-            return self.type(*args, **kwargs)
-
-    def utcnow(self):
-        """Returns an :class:`Arrow <arrow.arrow.Arrow>` object, representing "now" in UTC time.
-
-        Usage::
-
-            >>> import arrow
-            >>> arrow.utcnow()
-            <Arrow [2013-05-08T05:19:07.018993+00:00]>
-        """
-
-        return self.type.utcnow()
-
-    def now(self, tz=None):
-        """Returns an :class:`Arrow <arrow.arrow.Arrow>` object, representing "now" in the given
-        timezone.
-
-        :param tz: (optional) A :ref:`timezone expression <tz-expr>`.  Defaults to local time.
-
-        Usage::
-
-            >>> import arrow
-            >>> arrow.now()
-            <Arrow [2013-05-07T22:19:11.363410-07:00]>
-
-            >>> arrow.now('US/Pacific')
-            <Arrow [2013-05-07T22:19:15.251821-07:00]>
-
-            >>> arrow.now('+02:00')
-            <Arrow [2013-05-08T07:19:25.618646+02:00]>
-
-            >>> arrow.now('local')
-            <Arrow [2013-05-07T22:19:39.130059-07:00]>
-        """
-
-        if tz is None:
-            tz = dateutil_tz.tzlocal()
-        elif not isinstance(tz, dt_tzinfo):
-            tz = parser.TzinfoParser.parse(tz)
-
-        return self.type.now(tz)

client/ayon_core/vendor/python/python_2/arrow/formatter.py

@@ -1,139 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, division
-
-import calendar
-import re
-
-from dateutil import tz as dateutil_tz
-
-from arrow import locales, util
-
-FORMAT_ATOM = "YYYY-MM-DD HH:mm:ssZZ"
-FORMAT_COOKIE = "dddd, DD-MMM-YYYY HH:mm:ss ZZZ"
-FORMAT_RFC822 = "ddd, DD MMM YY HH:mm:ss Z"
-FORMAT_RFC850 = "dddd, DD-MMM-YY HH:mm:ss ZZZ"
-FORMAT_RFC1036 = "ddd, DD MMM YY HH:mm:ss Z"
-FORMAT_RFC1123 = "ddd, DD MMM YYYY HH:mm:ss Z"
-FORMAT_RFC2822 = "ddd, DD MMM YYYY HH:mm:ss Z"
-FORMAT_RFC3339 = "YYYY-MM-DD HH:mm:ssZZ"
-FORMAT_RSS = "ddd, DD MMM YYYY HH:mm:ss Z"
-FORMAT_W3C = "YYYY-MM-DD HH:mm:ssZZ"
-
-
-class DateTimeFormatter(object):
-
-    # This pattern matches characters enclosed in square brackets are matched as
-    # an atomic group. For more info on atomic groups and how to they are
-    # emulated in Python's re library, see https://stackoverflow.com/a/13577411/2701578
-
-    _FORMAT_RE = re.compile(
-        r"(\[(?:(?=(?P<literal>[^]]))(?P=literal))*\]|YYY?Y?|MM?M?M?|Do|DD?D?D?|d?dd?d?|HH?|hh?|mm?|ss?|SS?S?S?S?S?|ZZ?Z?|a|A|X|x|W)"
-    )
-
-    def __init__(self, locale="en_us"):
-
-        self.locale = locales.get_locale(locale)
-
-    def format(cls, dt, fmt):
-
-        return cls._FORMAT_RE.sub(lambda m: cls._format_token(dt, m.group(0)), fmt)
-
-    def _format_token(self, dt, token):
-
-        if token and token.startswith("[") and token.endswith("]"):
-            return token[1:-1]
-
-        if token == "YYYY":
-            return self.locale.year_full(dt.year)
-        if token == "YY":
-            return self.locale.year_abbreviation(dt.year)
-
-        if token == "MMMM":
-            return self.locale.month_name(dt.month)
-        if token == "MMM":
-            return self.locale.month_abbreviation(dt.month)
-        if token == "MM":
-            return "{:02d}".format(dt.month)
-        if token == "M":
-            return str(dt.month)
-
-        if token == "DDDD":
-            return "{:03d}".format(dt.timetuple().tm_yday)
-        if token == "DDD":
-            return str(dt.timetuple().tm_yday)
-        if token == "DD":
-            return "{:02d}".format(dt.day)
-        if token == "D":
-            return str(dt.day)
-
-        if token == "Do":
-            return self.locale.ordinal_number(dt.day)
-
-        if token == "dddd":
-            return self.locale.day_name(dt.isoweekday())
-        if token == "ddd":
-            return self.locale.day_abbreviation(dt.isoweekday())
-        if token == "d":
-            return str(dt.isoweekday())
-
-        if token == "HH":
-            return "{:02d}".format(dt.hour)
-        if token == "H":
-            return str(dt.hour)
-        if token == "hh":
-            return "{:02d}".format(dt.hour if 0 < dt.hour < 13 else abs(dt.hour - 12))
-        if token == "h":
-            return str(dt.hour if 0 < dt.hour < 13 else abs(dt.hour - 12))
-
-        if token == "mm":
-            return "{:02d}".format(dt.minute)
-        if token == "m":
-            return str(dt.minute)
-
-        if token == "ss":
-            return "{:02d}".format(dt.second)
-        if token == "s":
-            return str(dt.second)
-
-        if token == "SSSSSS":
-            return str("{:06d}".format(int(dt.microsecond)))
-        if token == "SSSSS":
-            return str("{:05d}".format(int(dt.microsecond / 10)))
-        if token == "SSSS":
-            return str("{:04d}".format(int(dt.microsecond / 100)))
-        if token == "SSS":
-            return str("{:03d}".format(int(dt.microsecond / 1000)))
-        if token == "SS":
-            return str("{:02d}".format(int(dt.microsecond / 10000)))
-        if token == "S":
-            return str(int(dt.microsecond / 100000))
-
-        if token == "X":
-            # TODO: replace with a call to dt.timestamp() when we drop Python 2.7
-            return str(calendar.timegm(dt.utctimetuple()))
-
-        if token == "x":
-            # TODO: replace with a call to dt.timestamp() when we drop Python 2.7
-            ts = calendar.timegm(dt.utctimetuple()) + (dt.microsecond / 1000000)
-            return str(int(ts * 1000000))
-
-        if token == "ZZZ":
-            return dt.tzname()
-
-        if token in ["ZZ", "Z"]:
-            separator = ":" if token == "ZZ" else ""
-            tz = dateutil_tz.tzutc() if dt.tzinfo is None else dt.tzinfo
-            total_minutes = int(util.total_seconds(tz.utcoffset(dt)) / 60)
-
-            sign = "+" if total_minutes >= 0 else "-"
-            total_minutes = abs(total_minutes)
-            hour, minute = divmod(total_minutes, 60)
-
-            return "{}{:02d}{}{:02d}".format(sign, hour, separator, minute)
-
-        if token in ("a", "A"):
-            return self.locale.meridian(dt.hour, token)
-
-        if token == "W":
-            year, week, day = dt.isocalendar()
-            return "{}-W{:02d}-{}".format(year, week, day)

client/ayon_core/vendor/python/python_2/arrow/parser.py

@@ -1,596 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import, unicode_literals
-
-import re
-from datetime import datetime, timedelta
-
-from dateutil import tz
-
-from arrow import locales
-from arrow.util import iso_to_gregorian, next_weekday, normalize_timestamp
-
-try:
-    from functools import lru_cache
-except ImportError:  # pragma: no cover
-    from backports.functools_lru_cache import lru_cache  # pragma: no cover
-
-
-class ParserError(ValueError):
-    pass
-
-
-# Allows for ParserErrors to be propagated from _build_datetime()
-# when day_of_year errors occur.
-# Before this, the ParserErrors were caught by the try/except in
-# _parse_multiformat() and the appropriate error message was not
-# transmitted to the user.
-class ParserMatchError(ParserError):
-    pass
-
-
-class DateTimeParser(object):
-
-    _FORMAT_RE = re.compile(
-        r"(YYY?Y?|MM?M?M?|Do|DD?D?D?|d?d?d?d|HH?|hh?|mm?|ss?|S+|ZZ?Z?|a|A|x|X|W)"
-    )
-    _ESCAPE_RE = re.compile(r"\[[^\[\]]*\]")
-
-    _ONE_OR_TWO_DIGIT_RE = re.compile(r"\d{1,2}")
-    _ONE_OR_TWO_OR_THREE_DIGIT_RE = re.compile(r"\d{1,3}")
-    _ONE_OR_MORE_DIGIT_RE = re.compile(r"\d+")
-    _TWO_DIGIT_RE = re.compile(r"\d{2}")
-    _THREE_DIGIT_RE = re.compile(r"\d{3}")
-    _FOUR_DIGIT_RE = re.compile(r"\d{4}")
-    _TZ_Z_RE = re.compile(r"([\+\-])(\d{2})(?:(\d{2}))?|Z")
-    _TZ_ZZ_RE = re.compile(r"([\+\-])(\d{2})(?:\:(\d{2}))?|Z")
-    _TZ_NAME_RE = re.compile(r"\w[\w+\-/]+")
-    # NOTE: timestamps cannot be parsed from natural language strings (by removing the ^...$) because it will
-    # break cases like "15 Jul 2000" and a format list (see issue #447)
-    _TIMESTAMP_RE = re.compile(r"^\-?\d+\.?\d+$")
-    _TIMESTAMP_EXPANDED_RE = re.compile(r"^\-?\d+$")
-    _TIME_RE = re.compile(r"^(\d{2})(?:\:?(\d{2}))?(?:\:?(\d{2}))?(?:([\.\,])(\d+))?$")
-    _WEEK_DATE_RE = re.compile(r"(?P<year>\d{4})[\-]?W(?P<week>\d{2})[\-]?(?P<day>\d)?")
-
-    _BASE_INPUT_RE_MAP = {
-        "YYYY": _FOUR_DIGIT_RE,
-        "YY": _TWO_DIGIT_RE,
-        "MM": _TWO_DIGIT_RE,
-        "M": _ONE_OR_TWO_DIGIT_RE,
-        "DDDD": _THREE_DIGIT_RE,
-        "DDD": _ONE_OR_TWO_OR_THREE_DIGIT_RE,
-        "DD": _TWO_DIGIT_RE,
-        "D": _ONE_OR_TWO_DIGIT_RE,
-        "HH": _TWO_DIGIT_RE,
-        "H": _ONE_OR_TWO_DIGIT_RE,
-        "hh": _TWO_DIGIT_RE,
-        "h": _ONE_OR_TWO_DIGIT_RE,
-        "mm": _TWO_DIGIT_RE,
-        "m": _ONE_OR_TWO_DIGIT_RE,
-        "ss": _TWO_DIGIT_RE,
-        "s": _ONE_OR_TWO_DIGIT_RE,
-        "X": _TIMESTAMP_RE,
-        "x": _TIMESTAMP_EXPANDED_RE,
-        "ZZZ": _TZ_NAME_RE,
-        "ZZ": _TZ_ZZ_RE,
-        "Z": _TZ_Z_RE,
-        "S": _ONE_OR_MORE_DIGIT_RE,
-        "W": _WEEK_DATE_RE,
-    }
-
-    SEPARATORS = ["-", "/", "."]
-
-    def __init__(self, locale="en_us", cache_size=0):
-
-        self.locale = locales.get_locale(locale)
-        self._input_re_map = self._BASE_INPUT_RE_MAP.copy()
-        self._input_re_map.update(
-            {
-                "MMMM": self._generate_choice_re(
-                    self.locale.month_names[1:], re.IGNORECASE
-                ),
-                "MMM": self._generate_choice_re(
-                    self.locale.month_abbreviations[1:], re.IGNORECASE
-                ),
-                "Do": re.compile(self.locale.ordinal_day_re),
-                "dddd": self._generate_choice_re(
-                    self.locale.day_names[1:], re.IGNORECASE
-                ),
-                "ddd": self._generate_choice_re(
-                    self.locale.day_abbreviations[1:], re.IGNORECASE
-                ),
-                "d": re.compile(r"[1-7]"),
-                "a": self._generate_choice_re(
-                    (self.locale.meridians["am"], self.locale.meridians["pm"])
-                ),
-                # note: 'A' token accepts both 'am/pm' and 'AM/PM' formats to
-                # ensure backwards compatibility of this token
-                "A": self._generate_choice_re(self.locale.meridians.values()),
-            }
-        )
-        if cache_size > 0:
-            self._generate_pattern_re = lru_cache(maxsize=cache_size)(
-                self._generate_pattern_re
-            )
-
-    # TODO: since we support more than ISO 8601, we should rename this function
-    # IDEA: break into multiple functions
-    def parse_iso(self, datetime_string, normalize_whitespace=False):
-
-        if normalize_whitespace:
-            datetime_string = re.sub(r"\s+", " ", datetime_string.strip())
-
-        has_space_divider = " " in datetime_string
-        has_t_divider = "T" in datetime_string
-
-        num_spaces = datetime_string.count(" ")
-        if has_space_divider and num_spaces != 1 or has_t_divider and num_spaces > 0:
-            raise ParserError(
-                "Expected an ISO 8601-like string, but was given '{}'. Try passing in a format string to resolve this.".format(
-                    datetime_string
-                )
-            )
-
-        has_time = has_space_divider or has_t_divider
-        has_tz = False
-
-        # date formats (ISO 8601 and others) to test against
-        # NOTE: YYYYMM is omitted to avoid confusion with YYMMDD (no longer part of ISO 8601, but is still often used)
-        formats = [
-            "YYYY-MM-DD",
-            "YYYY-M-DD",
-            "YYYY-M-D",
-            "YYYY/MM/DD",
-            "YYYY/M/DD",
-            "YYYY/M/D",
-            "YYYY.MM.DD",
-            "YYYY.M.DD",
-            "YYYY.M.D",
-            "YYYYMMDD",
-            "YYYY-DDDD",
-            "YYYYDDDD",
-            "YYYY-MM",
-            "YYYY/MM",
-            "YYYY.MM",
-            "YYYY",
-            "W",
-        ]
-
-        if has_time:
-
-            if has_space_divider:
-                date_string, time_string = datetime_string.split(" ", 1)
-            else:
-                date_string, time_string = datetime_string.split("T", 1)
-
-            time_parts = re.split(r"[\+\-Z]", time_string, 1, re.IGNORECASE)
-
-            time_components = self._TIME_RE.match(time_parts[0])
-
-            if time_components is None:
-                raise ParserError(
-                    "Invalid time component provided. Please specify a format or provide a valid time component in the basic or extended ISO 8601 time format."
-                )
-
-            (
-                hours,
-                minutes,
-                seconds,
-                subseconds_sep,
-                subseconds,
-            ) = time_components.groups()
-
-            has_tz = len(time_parts) == 2
-            has_minutes = minutes is not None
-            has_seconds = seconds is not None
-            has_subseconds = subseconds is not None
-
-            is_basic_time_format = ":" not in time_parts[0]
-            tz_format = "Z"
-
-            # use 'ZZ' token instead since tz offset is present in non-basic format
-            if has_tz and ":" in time_parts[1]:
-                tz_format = "ZZ"
-
-            time_sep = "" if is_basic_time_format else ":"
-
-            if has_subseconds:
-                time_string = "HH{time_sep}mm{time_sep}ss{subseconds_sep}S".format(
-                    time_sep=time_sep, subseconds_sep=subseconds_sep
-                )
-            elif has_seconds:
-                time_string = "HH{time_sep}mm{time_sep}ss".format(time_sep=time_sep)
-            elif has_minutes:
-                time_string = "HH{time_sep}mm".format(time_sep=time_sep)
-            else:
-                time_string = "HH"
-
-            if has_space_divider:
-                formats = ["{} {}".format(f, time_string) for f in formats]
-            else:
-                formats = ["{}T{}".format(f, time_string) for f in formats]
-
-        if has_time and has_tz:
-            # Add "Z" or "ZZ" to the format strings to indicate to
-            # _parse_token() that a timezone needs to be parsed
-            formats = ["{}{}".format(f, tz_format) for f in formats]
-
-        return self._parse_multiformat(datetime_string, formats)
-
-    def parse(self, datetime_string, fmt, normalize_whitespace=False):
-
-        if normalize_whitespace:
-            datetime_string = re.sub(r"\s+", " ", datetime_string)
-
-        if isinstance(fmt, list):
-            return self._parse_multiformat(datetime_string, fmt)
-
-        fmt_tokens, fmt_pattern_re = self._generate_pattern_re(fmt)
-
-        match = fmt_pattern_re.search(datetime_string)
-
-        if match is None:
-            raise ParserMatchError(
-                "Failed to match '{}' when parsing '{}'".format(fmt, datetime_string)
-            )
-
-        parts = {}
-        for token in fmt_tokens:
-            if token == "Do":
-                value = match.group("value")
-            elif token == "W":
-                value = (match.group("year"), match.group("week"), match.group("day"))
-            else:
-                value = match.group(token)
-            self._parse_token(token, value, parts)
-
-        return self._build_datetime(parts)
-
-    def _generate_pattern_re(self, fmt):
-
-        # fmt is a string of tokens like 'YYYY-MM-DD'
-        # we construct a new string by replacing each
-        # token by its pattern:
-        # 'YYYY-MM-DD' -> '(?P<YYYY>\d{4})-(?P<MM>\d{2})-(?P<DD>\d{2})'
-        tokens = []
-        offset = 0
-
-        # Escape all special RegEx chars
-        escaped_fmt = re.escape(fmt)
-
-        # Extract the bracketed expressions to be reinserted later.
-        escaped_fmt = re.sub(self._ESCAPE_RE, "#", escaped_fmt)
-
-        # Any number of S is the same as one.
-        # TODO: allow users to specify the number of digits to parse
-        escaped_fmt = re.sub(r"S+", "S", escaped_fmt)
-
-        escaped_data = re.findall(self._ESCAPE_RE, fmt)
-
-        fmt_pattern = escaped_fmt
-
-        for m in self._FORMAT_RE.finditer(escaped_fmt):
-            token = m.group(0)
-            try:
-                input_re = self._input_re_map[token]
-            except KeyError:
-                raise ParserError("Unrecognized token '{}'".format(token))
-            input_pattern = "(?P<{}>{})".format(token, input_re.pattern)
-            tokens.append(token)
-            # a pattern doesn't have the same length as the token
-            # it replaces! We keep the difference in the offset variable.
-            # This works because the string is scanned left-to-right and matches
-            # are returned in the order found by finditer.
-            fmt_pattern = (
-                fmt_pattern[: m.start() + offset]
-                + input_pattern
-                + fmt_pattern[m.end() + offset :]
-            )
-            offset += len(input_pattern) - (m.end() - m.start())
-
-        final_fmt_pattern = ""
-        split_fmt = fmt_pattern.split(r"\#")
-
-        # Due to the way Python splits, 'split_fmt' will always be longer
-        for i in range(len(split_fmt)):
-            final_fmt_pattern += split_fmt[i]
-            if i < len(escaped_data):
-                final_fmt_pattern += escaped_data[i][1:-1]
-
-        # Wrap final_fmt_pattern in a custom word boundary to strictly
-        # match the formatting pattern and filter out date and time formats
-        # that include junk such as: blah1998-09-12 blah, blah 1998-09-12blah,
-        # blah1998-09-12blah. The custom word boundary matches every character
-        # that is not a whitespace character to allow for searching for a date
-        # and time string in a natural language sentence. Therefore, searching
-        # for a string of the form YYYY-MM-DD in "blah 1998-09-12 blah" will
-        # work properly.
-        # Certain punctuation before or after the target pattern such as
-        # "1998-09-12," is permitted. For the full list of valid punctuation,
-        # see the documentation.
-
-        starting_word_boundary = (
-            r"(?<!\S\S)"  # Don't have two consecutive non-whitespace characters. This ensures that we allow cases like .11.25.2019 but not 1.11.25.2019 (for pattern MM.DD.YYYY)
-            r"(?<![^\,\.\;\:\?\!\"\'\`\[\]\{\}\(\)<>\s])"  # This is the list of punctuation that is ok before the pattern (i.e. "It can't not be these characters before the pattern")
-            r"(\b|^)"  # The \b is to block cases like 1201912 but allow 201912 for pattern YYYYMM. The ^ was necessary to allow a negative number through i.e. before epoch numbers
-        )
-        ending_word_boundary = (
-            r"(?=[\,\.\;\:\?\!\"\'\`\[\]\{\}\(\)\<\>]?"  # Positive lookahead stating that these punctuation marks can appear after the pattern at most 1 time
-            r"(?!\S))"  # Don't allow any non-whitespace character after the punctuation
-        )
-        bounded_fmt_pattern = r"{}{}{}".format(
-            starting_word_boundary, final_fmt_pattern, ending_word_boundary
-        )
-
-        return tokens, re.compile(bounded_fmt_pattern, flags=re.IGNORECASE)
-
-    def _parse_token(self, token, value, parts):
-
-        if token == "YYYY":
-            parts["year"] = int(value)
-
-        elif token == "YY":
-            value = int(value)
-            parts["year"] = 1900 + value if value > 68 else 2000 + value
-
-        elif token in ["MMMM", "MMM"]:
-            parts["month"] = self.locale.month_number(value.lower())
-
-        elif token in ["MM", "M"]:
-            parts["month"] = int(value)
-
-        elif token in ["DDDD", "DDD"]:
-            parts["day_of_year"] = int(value)
-
-        elif token in ["DD", "D"]:
-            parts["day"] = int(value)
-
-        elif token == "Do":
-            parts["day"] = int(value)
-
-        elif token == "dddd":
-            # locale day names are 1-indexed
-            day_of_week = [x.lower() for x in self.locale.day_names].index(
-                value.lower()
-            )
-            parts["day_of_week"] = day_of_week - 1
-
-        elif token == "ddd":
-            # locale day abbreviations are 1-indexed
-            day_of_week = [x.lower() for x in self.locale.day_abbreviations].index(
-                value.lower()
-            )
-            parts["day_of_week"] = day_of_week - 1
-
-        elif token.upper() in ["HH", "H"]:
-            parts["hour"] = int(value)
-
-        elif token in ["mm", "m"]:
-            parts["minute"] = int(value)
-
-        elif token in ["ss", "s"]:
-            parts["second"] = int(value)
-
-        elif token == "S":
-            # We have the *most significant* digits of an arbitrary-precision integer.
-            # We want the six most significant digits as an integer, rounded.
-            # IDEA: add nanosecond support somehow? Need datetime support for it first.
-            value = value.ljust(7, str("0"))
-
-            # floating-point (IEEE-754) defaults to half-to-even rounding
-            seventh_digit = int(value[6])
-            if seventh_digit == 5:
-                rounding = int(value[5]) % 2
-            elif seventh_digit > 5:
-                rounding = 1
-            else:
-                rounding = 0
-
-            parts["microsecond"] = int(value[:6]) + rounding
-
-        elif token == "X":
-            parts["timestamp"] = float(value)
-
-        elif token == "x":
-            parts["expanded_timestamp"] = int(value)
-
-        elif token in ["ZZZ", "ZZ", "Z"]:
-            parts["tzinfo"] = TzinfoParser.parse(value)
-
-        elif token in ["a", "A"]:
-            if value in (self.locale.meridians["am"], self.locale.meridians["AM"]):
-                parts["am_pm"] = "am"
-            elif value in (self.locale.meridians["pm"], self.locale.meridians["PM"]):
-                parts["am_pm"] = "pm"
-
-        elif token == "W":
-            parts["weekdate"] = value
-
-    @staticmethod
-    def _build_datetime(parts):
-
-        weekdate = parts.get("weekdate")
-
-        if weekdate is not None:
-            # we can use strptime (%G, %V, %u) in python 3.6 but these tokens aren't available before that
-            year, week = int(weekdate[0]), int(weekdate[1])
-
-            if weekdate[2] is not None:
-                day = int(weekdate[2])
-            else:
-                # day not given, default to 1
-                day = 1
-
-            dt = iso_to_gregorian(year, week, day)
-            parts["year"] = dt.year
-            parts["month"] = dt.month
-            parts["day"] = dt.day
-
-        timestamp = parts.get("timestamp")
-
-        if timestamp is not None:
-            return datetime.fromtimestamp(timestamp, tz=tz.tzutc())
-
-        expanded_timestamp = parts.get("expanded_timestamp")
-
-        if expanded_timestamp is not None:
-            return datetime.fromtimestamp(
-                normalize_timestamp(expanded_timestamp),
-                tz=tz.tzutc(),
-            )
-
-        day_of_year = parts.get("day_of_year")
-
-        if day_of_year is not None:
-            year = parts.get("year")
-            month = parts.get("month")
-            if year is None:
-                raise ParserError(
-                    "Year component is required with the DDD and DDDD tokens."
-                )
-
-            if month is not None:
-                raise ParserError(
-                    "Month component is not allowed with the DDD and DDDD tokens."
-                )
-
-            date_string = "{}-{}".format(year, day_of_year)
-            try:
-                dt = datetime.strptime(date_string, "%Y-%j")
-            except ValueError:
-                raise ParserError(
-                    "The provided day of year '{}' is invalid.".format(day_of_year)
-                )
-
-            parts["year"] = dt.year
-            parts["month"] = dt.month
-            parts["day"] = dt.day
-
-        day_of_week = parts.get("day_of_week")
-        day = parts.get("day")
-
-        # If day is passed, ignore day of week
-        if day_of_week is not None and day is None:
-            year = parts.get("year", 1970)
-            month = parts.get("month", 1)
-            day = 1
-
-            # dddd => first day of week after epoch
-            # dddd YYYY => first day of week in specified year
-            # dddd MM YYYY => first day of week in specified year and month
-            # dddd MM => first day after epoch in specified month
-            next_weekday_dt = next_weekday(datetime(year, month, day), day_of_week)
-            parts["year"] = next_weekday_dt.year
-            parts["month"] = next_weekday_dt.month
-            parts["day"] = next_weekday_dt.day
-
-        am_pm = parts.get("am_pm")
-        hour = parts.get("hour", 0)
-
-        if am_pm == "pm" and hour < 12:
-            hour += 12
-        elif am_pm == "am" and hour == 12:
-            hour = 0
-
-        # Support for midnight at the end of day
-        if hour == 24:
-            if parts.get("minute", 0) != 0:
-                raise ParserError("Midnight at the end of day must not contain minutes")
-            if parts.get("second", 0) != 0:
-                raise ParserError("Midnight at the end of day must not contain seconds")
-            if parts.get("microsecond", 0) != 0:
-                raise ParserError(
-                    "Midnight at the end of day must not contain microseconds"
-                )
-            hour = 0
-            day_increment = 1
-        else:
-            day_increment = 0
-
-        # account for rounding up to 1000000
-        microsecond = parts.get("microsecond", 0)
-        if microsecond == 1000000:
-            microsecond = 0
-            second_increment = 1
-        else:
-            second_increment = 0
-
-        increment = timedelta(days=day_increment, seconds=second_increment)
-
-        return (
-            datetime(
-                year=parts.get("year", 1),
-                month=parts.get("month", 1),
-                day=parts.get("day", 1),
-                hour=hour,
-                minute=parts.get("minute", 0),
-                second=parts.get("second", 0),
-                microsecond=microsecond,
-                tzinfo=parts.get("tzinfo"),
-            )
-            + increment
-        )
-
-    def _parse_multiformat(self, string, formats):
-
-        _datetime = None
-
-        for fmt in formats:
-            try:
-                _datetime = self.parse(string, fmt)
-                break
-            except ParserMatchError:
-                pass
-
-        if _datetime is None:
-            raise ParserError(
-                "Could not match input '{}' to any of the following formats: {}".format(
-                    string, ", ".join(formats)
-                )
-            )
-
-        return _datetime
-
-    # generates a capture group of choices separated by an OR operator
-    @staticmethod
-    def _generate_choice_re(choices, flags=0):
-        return re.compile(r"({})".format("|".join(choices)), flags=flags)
-
-
-class TzinfoParser(object):
-    _TZINFO_RE = re.compile(r"^([\+\-])?(\d{2})(?:\:?(\d{2}))?$")
-
-    @classmethod
-    def parse(cls, tzinfo_string):
-
-        tzinfo = None
-
-        if tzinfo_string == "local":
-            tzinfo = tz.tzlocal()
-
-        elif tzinfo_string in ["utc", "UTC", "Z"]:
-            tzinfo = tz.tzutc()
-
-        else:
-
-            iso_match = cls._TZINFO_RE.match(tzinfo_string)
-
-            if iso_match:
-                sign, hours, minutes = iso_match.groups()
-                if minutes is None:
-                    minutes = 0
-                seconds = int(hours) * 3600 + int(minutes) * 60
-
-                if sign == "-":
-                    seconds *= -1
-
-                tzinfo = tz.tzoffset(None, seconds)
-
-            else:
-                tzinfo = tz.gettz(tzinfo_string)
-
-        if tzinfo is None:
-            raise ParserError(
-                'Could not parse timezone expression "{}"'.format(tzinfo_string)
-            )
-
-        return tzinfo

client/ayon_core/vendor/python/python_2/arrow/util.py

@@ -1,115 +0,0 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import
-
-import datetime
-import numbers
-
-from dateutil.rrule import WEEKLY, rrule
-
-from arrow.constants import MAX_TIMESTAMP, MAX_TIMESTAMP_MS, MAX_TIMESTAMP_US
-
-
-def next_weekday(start_date, weekday):
-    """Get next weekday from the specified start date.
-
-    :param start_date: Datetime object representing the start date.
-    :param weekday: Next weekday to obtain. Can be a value between 0 (Monday) and 6 (Sunday).
-    :return: Datetime object corresponding to the next weekday after start_date.
-
-    Usage::
-
-        # Get first Monday after epoch
-        >>> next_weekday(datetime(1970, 1, 1), 0)
-        1970-01-05 00:00:00
-
-        # Get first Thursday after epoch
-        >>> next_weekday(datetime(1970, 1, 1), 3)
-        1970-01-01 00:00:00
-
-        # Get first Sunday after epoch
-        >>> next_weekday(datetime(1970, 1, 1), 6)
-        1970-01-04 00:00:00
-    """
-    if weekday < 0 or weekday > 6:
-        raise ValueError("Weekday must be between 0 (Monday) and 6 (Sunday).")
-    return rrule(freq=WEEKLY, dtstart=start_date, byweekday=weekday, count=1)[0]
-
-
-def total_seconds(td):
-    """Get total seconds for timedelta."""
-    return td.total_seconds()
-
-
-def is_timestamp(value):
-    """Check if value is a valid timestamp."""
-    if isinstance(value, bool):
-        return False
-    if not (
-        isinstance(value, numbers.Integral)
-        or isinstance(value, float)
-        or isinstance(value, str)
-    ):
-        return False
-    try:
-        float(value)
-        return True
-    except ValueError:
-        return False
-
-
-def normalize_timestamp(timestamp):
-    """Normalize millisecond and microsecond timestamps into normal timestamps."""
-    if timestamp > MAX_TIMESTAMP:
-        if timestamp < MAX_TIMESTAMP_MS:
-            timestamp /= 1e3
-        elif timestamp < MAX_TIMESTAMP_US:
-            timestamp /= 1e6
-        else:
-            raise ValueError(
-                "The specified timestamp '{}' is too large.".format(timestamp)
-            )
-    return timestamp
-
-
-# Credit to https://stackoverflow.com/a/1700069
-def iso_to_gregorian(iso_year, iso_week, iso_day):
-    """Converts an ISO week date tuple into a datetime object."""
-
-    if not 1 <= iso_week <= 53:
-        raise ValueError("ISO Calendar week value must be between 1-53.")
-
-    if not 1 <= iso_day <= 7:
-        raise ValueError("ISO Calendar day value must be between 1-7")
-
-    # The first week of the year always contains 4 Jan.
-    fourth_jan = datetime.date(iso_year, 1, 4)
-    delta = datetime.timedelta(fourth_jan.isoweekday() - 1)
-    year_start = fourth_jan - delta
-    gregorian = year_start + datetime.timedelta(days=iso_day - 1, weeks=iso_week - 1)
-
-    return gregorian
-
-
-def validate_bounds(bounds):
-    if bounds != "()" and bounds != "(]" and bounds != "[)" and bounds != "[]":
-        raise ValueError(
-            'Invalid bounds. Please select between "()", "(]", "[)", or "[]".'
-        )
-
-
-# Python 2.7 / 3.0+ definitions for isstr function.
-
-try:  # pragma: no cover
-    basestring
-
-    def isstr(s):
-        return isinstance(s, basestring)  # noqa: F821
-
-
-except NameError:  # pragma: no cover
-
-    def isstr(s):
-        return isinstance(s, str)
-
-
-__all__ = ["next_weekday", "total_seconds", "is_timestamp", "isstr", "iso_to_gregorian"]

client/ayon_core/vendor/python/python_2/attr/__init__.py

@@ -1,80 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-import sys
-
-from functools import partial
-
-from . import converters, exceptions, filters, setters, validators
-from ._cmp import cmp_using
-from ._config import get_run_validators, set_run_validators
-from ._funcs import asdict, assoc, astuple, evolve, has, resolve_types
-from ._make import (
-    NOTHING,
-    Attribute,
-    Factory,
-    attrib,
-    attrs,
-    fields,
-    fields_dict,
-    make_class,
-    validate,
-)
-from ._version_info import VersionInfo
-
-
-__version__ = "21.4.0"
-__version_info__ = VersionInfo._from_version_string(__version__)
-
-__title__ = "attrs"
-__description__ = "Classes Without Boilerplate"
-__url__ = "https://www.attrs.org/"
-__uri__ = __url__
-__doc__ = __description__ + " <" + __uri__ + ">"
-
-__author__ = "Hynek Schlawack"
-__email__ = "hs@ox.cx"
-
-__license__ = "MIT"
-__copyright__ = "Copyright (c) 2015 Hynek Schlawack"
-
-
-s = attributes = attrs
-ib = attr = attrib
-dataclass = partial(attrs, auto_attribs=True)  # happy Easter ;)
-
-__all__ = [
-    "Attribute",
-    "Factory",
-    "NOTHING",
-    "asdict",
-    "assoc",
-    "astuple",
-    "attr",
-    "attrib",
-    "attributes",
-    "attrs",
-    "cmp_using",
-    "converters",
-    "evolve",
-    "exceptions",
-    "fields",
-    "fields_dict",
-    "filters",
-    "get_run_validators",
-    "has",
-    "ib",
-    "make_class",
-    "resolve_types",
-    "s",
-    "set_run_validators",
-    "setters",
-    "validate",
-    "validators",
-]
-
-if sys.version_info[:2] >= (3, 6):
-    from ._next_gen import define, field, frozen, mutable  # noqa: F401
-
-    __all__.extend(("define", "field", "frozen", "mutable"))

client/ayon_core/vendor/python/python_2/attr/__init__.pyi

@@ -1,484 +0,0 @@
-import sys
-
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Generic,
-    List,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-
-# `import X as X` is required to make these public
-from . import converters as converters
-from . import exceptions as exceptions
-from . import filters as filters
-from . import setters as setters
-from . import validators as validators
-from ._version_info import VersionInfo
-
-__version__: str
-__version_info__: VersionInfo
-__title__: str
-__description__: str
-__url__: str
-__uri__: str
-__author__: str
-__email__: str
-__license__: str
-__copyright__: str
-
-_T = TypeVar("_T")
-_C = TypeVar("_C", bound=type)
-
-_EqOrderType = Union[bool, Callable[[Any], Any]]
-_ValidatorType = Callable[[Any, Attribute[_T], _T], Any]
-_ConverterType = Callable[[Any], Any]
-_FilterType = Callable[[Attribute[_T], _T], bool]
-_ReprType = Callable[[Any], str]
-_ReprArgType = Union[bool, _ReprType]
-_OnSetAttrType = Callable[[Any, Attribute[Any], Any], Any]
-_OnSetAttrArgType = Union[
-    _OnSetAttrType, List[_OnSetAttrType], setters._NoOpType
-]
-_FieldTransformer = Callable[
-    [type, List[Attribute[Any]]], List[Attribute[Any]]
-]
-_CompareWithType = Callable[[Any, Any], bool]
-# FIXME: in reality, if multiple validators are passed they must be in a list
-# or tuple, but those are invariant and so would prevent subtypes of
-# _ValidatorType from working when passed in a list or tuple.
-_ValidatorArgType = Union[_ValidatorType[_T], Sequence[_ValidatorType[_T]]]
-
-# _make --
-
-NOTHING: object
-
-# NOTE: Factory lies about its return type to make this possible:
-# `x: List[int] # = Factory(list)`
-# Work around mypy issue #4554 in the common case by using an overload.
-if sys.version_info >= (3, 8):
-    from typing import Literal
-    @overload
-    def Factory(factory: Callable[[], _T]) -> _T: ...
-    @overload
-    def Factory(
-        factory: Callable[[Any], _T],
-        takes_self: Literal[True],
-    ) -> _T: ...
-    @overload
-    def Factory(
-        factory: Callable[[], _T],
-        takes_self: Literal[False],
-    ) -> _T: ...
-
-else:
-    @overload
-    def Factory(factory: Callable[[], _T]) -> _T: ...
-    @overload
-    def Factory(
-        factory: Union[Callable[[Any], _T], Callable[[], _T]],
-        takes_self: bool = ...,
-    ) -> _T: ...
-
-# Static type inference support via __dataclass_transform__ implemented as per:
-# https://github.com/microsoft/pyright/blob/1.1.135/specs/dataclass_transforms.md
-# This annotation must be applied to all overloads of "define" and "attrs"
-#
-# NOTE: This is a typing construct and does not exist at runtime.  Extensions
-# wrapping attrs decorators should declare a separate __dataclass_transform__
-# signature in the extension module using the specification linked above to
-# provide pyright support.
-def __dataclass_transform__(
-    *,
-    eq_default: bool = True,
-    order_default: bool = False,
-    kw_only_default: bool = False,
-    field_descriptors: Tuple[Union[type, Callable[..., Any]], ...] = (()),
-) -> Callable[[_T], _T]: ...
-
-class Attribute(Generic[_T]):
-    name: str
-    default: Optional[_T]
-    validator: Optional[_ValidatorType[_T]]
-    repr: _ReprArgType
-    cmp: _EqOrderType
-    eq: _EqOrderType
-    order: _EqOrderType
-    hash: Optional[bool]
-    init: bool
-    converter: Optional[_ConverterType]
-    metadata: Dict[Any, Any]
-    type: Optional[Type[_T]]
-    kw_only: bool
-    on_setattr: _OnSetAttrType
-    def evolve(self, **changes: Any) -> "Attribute[Any]": ...
-
-# NOTE: We had several choices for the annotation to use for type arg:
-# 1) Type[_T]
-#   - Pros: Handles simple cases correctly
-#   - Cons: Might produce less informative errors in the case of conflicting
-#     TypeVars e.g. `attr.ib(default='bad', type=int)`
-# 2) Callable[..., _T]
-#   - Pros: Better error messages than #1 for conflicting TypeVars
-#   - Cons: Terrible error messages for validator checks.
-#   e.g. attr.ib(type=int, validator=validate_str)
-#        -> error: Cannot infer function type argument
-# 3) type (and do all of the work in the mypy plugin)
-#   - Pros: Simple here, and we could customize the plugin with our own errors.
-#   - Cons: Would need to write mypy plugin code to handle all the cases.
-# We chose option #1.
-
-# `attr` lies about its return type to make the following possible:
-#     attr()    -> Any
-#     attr(8)   -> int
-#     attr(validator=<some callable>)  -> Whatever the callable expects.
-# This makes this type of assignments possible:
-#     x: int = attr(8)
-#
-# This form catches explicit None or no default but with no other arguments
-# returns Any.
-@overload
-def attrib(
-    default: None = ...,
-    validator: None = ...,
-    repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    type: None = ...,
-    converter: None = ...,
-    factory: None = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> Any: ...
-
-# This form catches an explicit None or no default and infers the type from the
-# other arguments.
-@overload
-def attrib(
-    default: None = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    type: Optional[Type[_T]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> _T: ...
-
-# This form catches an explicit default argument.
-@overload
-def attrib(
-    default: _T,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    type: Optional[Type[_T]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> _T: ...
-
-# This form covers type=non-Type: e.g. forward references (str), Any
-@overload
-def attrib(
-    default: Optional[_T] = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    type: object = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> Any: ...
-@overload
-def field(
-    *,
-    default: None = ...,
-    validator: None = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: None = ...,
-    factory: None = ...,
-    kw_only: bool = ...,
-    eq: Optional[bool] = ...,
-    order: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> Any: ...
-
-# This form catches an explicit None or no default and infers the type from the
-# other arguments.
-@overload
-def field(
-    *,
-    default: None = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> _T: ...
-
-# This form catches an explicit default argument.
-@overload
-def field(
-    *,
-    default: _T,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> _T: ...
-
-# This form covers type=non-Type: e.g. forward references (str), Any
-@overload
-def field(
-    *,
-    default: Optional[_T] = ...,
-    validator: Optional[_ValidatorArgType[_T]] = ...,
-    repr: _ReprArgType = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    metadata: Optional[Mapping[Any, Any]] = ...,
-    converter: Optional[_ConverterType] = ...,
-    factory: Optional[Callable[[], _T]] = ...,
-    kw_only: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-) -> Any: ...
-@overload
-@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
-def attrs(
-    maybe_cls: _C,
-    these: Optional[Dict[str, Any]] = ...,
-    repr_ns: Optional[str] = ...,
-    repr: bool = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    auto_detect: bool = ...,
-    collect_by_mro: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-    match_args: bool = ...,
-) -> _C: ...
-@overload
-@__dataclass_transform__(order_default=True, field_descriptors=(attrib, field))
-def attrs(
-    maybe_cls: None = ...,
-    these: Optional[Dict[str, Any]] = ...,
-    repr_ns: Optional[str] = ...,
-    repr: bool = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    auto_detect: bool = ...,
-    collect_by_mro: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-    match_args: bool = ...,
-) -> Callable[[_C], _C]: ...
-@overload
-@__dataclass_transform__(field_descriptors=(attrib, field))
-def define(
-    maybe_cls: _C,
-    *,
-    these: Optional[Dict[str, Any]] = ...,
-    repr: bool = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[bool] = ...,
-    order: Optional[bool] = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-    match_args: bool = ...,
-) -> _C: ...
-@overload
-@__dataclass_transform__(field_descriptors=(attrib, field))
-def define(
-    maybe_cls: None = ...,
-    *,
-    these: Optional[Dict[str, Any]] = ...,
-    repr: bool = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[bool] = ...,
-    order: Optional[bool] = ...,
-    auto_detect: bool = ...,
-    getstate_setstate: Optional[bool] = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-    match_args: bool = ...,
-) -> Callable[[_C], _C]: ...
-
-mutable = define
-frozen = define  # they differ only in their defaults
-
-# TODO: add support for returning NamedTuple from the mypy plugin
-class _Fields(Tuple[Attribute[Any], ...]):
-    def __getattr__(self, name: str) -> Attribute[Any]: ...
-
-def fields(cls: type) -> _Fields: ...
-def fields_dict(cls: type) -> Dict[str, Attribute[Any]]: ...
-def validate(inst: Any) -> None: ...
-def resolve_types(
-    cls: _C,
-    globalns: Optional[Dict[str, Any]] = ...,
-    localns: Optional[Dict[str, Any]] = ...,
-    attribs: Optional[List[Attribute[Any]]] = ...,
-) -> _C: ...
-
-# TODO: add support for returning a proper attrs class from the mypy plugin
-# we use Any instead of _CountingAttr so that e.g. `make_class('Foo',
-# [attr.ib()])` is valid
-def make_class(
-    name: str,
-    attrs: Union[List[str], Tuple[str, ...], Dict[str, Any]],
-    bases: Tuple[type, ...] = ...,
-    repr_ns: Optional[str] = ...,
-    repr: bool = ...,
-    cmp: Optional[_EqOrderType] = ...,
-    hash: Optional[bool] = ...,
-    init: bool = ...,
-    slots: bool = ...,
-    frozen: bool = ...,
-    weakref_slot: bool = ...,
-    str: bool = ...,
-    auto_attribs: bool = ...,
-    kw_only: bool = ...,
-    cache_hash: bool = ...,
-    auto_exc: bool = ...,
-    eq: Optional[_EqOrderType] = ...,
-    order: Optional[_EqOrderType] = ...,
-    collect_by_mro: bool = ...,
-    on_setattr: Optional[_OnSetAttrArgType] = ...,
-    field_transformer: Optional[_FieldTransformer] = ...,
-) -> type: ...
-
-# _funcs --
-
-# TODO: add support for returning TypedDict from the mypy plugin
-# FIXME: asdict/astuple do not honor their factory args. Waiting on one of
-# these:
-# https://github.com/python/mypy/issues/4236
-# https://github.com/python/typing/issues/253
-# XXX: remember to fix attrs.asdict/astuple too!
-def asdict(
-    inst: Any,
-    recurse: bool = ...,
-    filter: Optional[_FilterType[Any]] = ...,
-    dict_factory: Type[Mapping[Any, Any]] = ...,
-    retain_collection_types: bool = ...,
-    value_serializer: Optional[
-        Callable[[type, Attribute[Any], Any], Any]
-    ] = ...,
-    tuple_keys: Optional[bool] = ...,
-) -> Dict[str, Any]: ...
-
-# TODO: add support for returning NamedTuple from the mypy plugin
-def astuple(
-    inst: Any,
-    recurse: bool = ...,
-    filter: Optional[_FilterType[Any]] = ...,
-    tuple_factory: Type[Sequence[Any]] = ...,
-    retain_collection_types: bool = ...,
-) -> Tuple[Any, ...]: ...
-def has(cls: type) -> bool: ...
-def assoc(inst: _T, **changes: Any) -> _T: ...
-def evolve(inst: _T, **changes: Any) -> _T: ...
-
-# _config --
-
-def set_run_validators(run: bool) -> None: ...
-def get_run_validators() -> bool: ...
-
-# aliases --
-
-s = attributes = attrs
-ib = attr = attrib
-dataclass = attrs  # Technically, partial(attrs, auto_attribs=True) ;)

client/ayon_core/vendor/python/python_2/attr/_cmp.py

@@ -1,154 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-import functools
-
-from ._compat import new_class
-from ._make import _make_ne
-
-
-_operation_names = {"eq": "==", "lt": "<", "le": "<=", "gt": ">", "ge": ">="}
-
-
-def cmp_using(
-    eq=None,
-    lt=None,
-    le=None,
-    gt=None,
-    ge=None,
-    require_same_type=True,
-    class_name="Comparable",
-):
-    """
-    Create a class that can be passed into `attr.ib`'s ``eq``, ``order``, and
-    ``cmp`` arguments to customize field comparison.
-
-    The resulting class will have a full set of ordering methods if
-    at least one of ``{lt, le, gt, ge}`` and ``eq``  are provided.
-
-    :param Optional[callable] eq: `callable` used to evaluate equality
-        of two objects.
-    :param Optional[callable] lt: `callable` used to evaluate whether
-        one object is less than another object.
-    :param Optional[callable] le: `callable` used to evaluate whether
-        one object is less than or equal to another object.
-    :param Optional[callable] gt: `callable` used to evaluate whether
-        one object is greater than another object.
-    :param Optional[callable] ge: `callable` used to evaluate whether
-        one object is greater than or equal to another object.
-
-    :param bool require_same_type: When `True`, equality and ordering methods
-        will return `NotImplemented` if objects are not of the same type.
-
-    :param Optional[str] class_name: Name of class. Defaults to 'Comparable'.
-
-    See `comparison` for more details.
-
-    .. versionadded:: 21.1.0
-    """
-
-    body = {
-        "__slots__": ["value"],
-        "__init__": _make_init(),
-        "_requirements": [],
-        "_is_comparable_to": _is_comparable_to,
-    }
-
-    # Add operations.
-    num_order_functions = 0
-    has_eq_function = False
-
-    if eq is not None:
-        has_eq_function = True
-        body["__eq__"] = _make_operator("eq", eq)
-        body["__ne__"] = _make_ne()
-
-    if lt is not None:
-        num_order_functions += 1
-        body["__lt__"] = _make_operator("lt", lt)
-
-    if le is not None:
-        num_order_functions += 1
-        body["__le__"] = _make_operator("le", le)
-
-    if gt is not None:
-        num_order_functions += 1
-        body["__gt__"] = _make_operator("gt", gt)
-
-    if ge is not None:
-        num_order_functions += 1
-        body["__ge__"] = _make_operator("ge", ge)
-
-    type_ = new_class(class_name, (object,), {}, lambda ns: ns.update(body))
-
-    # Add same type requirement.
-    if require_same_type:
-        type_._requirements.append(_check_same_type)
-
-    # Add total ordering if at least one operation was defined.
-    if 0 < num_order_functions < 4:
-        if not has_eq_function:
-            # functools.total_ordering requires __eq__ to be defined,
-            # so raise early error here to keep a nice stack.
-            raise ValueError(
-                "eq must be define is order to complete ordering from "
-                "lt, le, gt, ge."
-            )
-        type_ = functools.total_ordering(type_)
-
-    return type_
-
-
-def _make_init():
-    """
-    Create __init__ method.
-    """
-
-    def __init__(self, value):
-        """
-        Initialize object with *value*.
-        """
-        self.value = value
-
-    return __init__
-
-
-def _make_operator(name, func):
-    """
-    Create operator method.
-    """
-
-    def method(self, other):
-        if not self._is_comparable_to(other):
-            return NotImplemented
-
-        result = func(self.value, other.value)
-        if result is NotImplemented:
-            return NotImplemented
-
-        return result
-
-    method.__name__ = "__%s__" % (name,)
-    method.__doc__ = "Return a %s b.  Computed by attrs." % (
-        _operation_names[name],
-    )
-
-    return method
-
-
-def _is_comparable_to(self, other):
-    """
-    Check whether `other` is comparable to `self`.
-    """
-    for func in self._requirements:
-        if not func(self, other):
-            return False
-    return True
-
-
-def _check_same_type(self, other):
-    """
-    Return True if *self* and *other* are of the same type, False otherwise.
-    """
-    return other.value.__class__ is self.value.__class__

client/ayon_core/vendor/python/python_2/attr/_cmp.pyi

@@ -1,13 +0,0 @@
-from typing import Type
-
-from . import _CompareWithType
-
-def cmp_using(
-    eq: Optional[_CompareWithType],
-    lt: Optional[_CompareWithType],
-    le: Optional[_CompareWithType],
-    gt: Optional[_CompareWithType],
-    ge: Optional[_CompareWithType],
-    require_same_type: bool,
-    class_name: str,
-) -> Type: ...

client/ayon_core/vendor/python/python_2/attr/_compat.py

@@ -1,261 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-import platform
-import sys
-import threading
-import types
-import warnings
-
-
-PY2 = sys.version_info[0] == 2
-PYPY = platform.python_implementation() == "PyPy"
-PY36 = sys.version_info[:2] >= (3, 6)
-HAS_F_STRINGS = PY36
-PY310 = sys.version_info[:2] >= (3, 10)
-
-
-if PYPY or PY36:
-    ordered_dict = dict
-else:
-    from collections import OrderedDict
-
-    ordered_dict = OrderedDict
-
-
-if PY2:
-    from collections import Mapping, Sequence
-
-    from UserDict import IterableUserDict
-
-    # We 'bundle' isclass instead of using inspect as importing inspect is
-    # fairly expensive (order of 10-15 ms for a modern machine in 2016)
-    def isclass(klass):
-        return isinstance(klass, (type, types.ClassType))
-
-    def new_class(name, bases, kwds, exec_body):
-        """
-        A minimal stub of types.new_class that we need for make_class.
-        """
-        ns = {}
-        exec_body(ns)
-
-        return type(name, bases, ns)
-
-    # TYPE is used in exceptions, repr(int) is different on Python 2 and 3.
-    TYPE = "type"
-
-    def iteritems(d):
-        return d.iteritems()
-
-    # Python 2 is bereft of a read-only dict proxy, so we make one!
-    class ReadOnlyDict(IterableUserDict):
-        """
-        Best-effort read-only dict wrapper.
-        """
-
-        def __setitem__(self, key, val):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise TypeError(
-                "'mappingproxy' object does not support item assignment"
-            )
-
-        def update(self, _):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError(
-                "'mappingproxy' object has no attribute 'update'"
-            )
-
-        def __delitem__(self, _):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise TypeError(
-                "'mappingproxy' object does not support item deletion"
-            )
-
-        def clear(self):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError(
-                "'mappingproxy' object has no attribute 'clear'"
-            )
-
-        def pop(self, key, default=None):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError(
-                "'mappingproxy' object has no attribute 'pop'"
-            )
-
-        def popitem(self):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError(
-                "'mappingproxy' object has no attribute 'popitem'"
-            )
-
-        def setdefault(self, key, default=None):
-            # We gently pretend we're a Python 3 mappingproxy.
-            raise AttributeError(
-                "'mappingproxy' object has no attribute 'setdefault'"
-            )
-
-        def __repr__(self):
-            # Override to be identical to the Python 3 version.
-            return "mappingproxy(" + repr(self.data) + ")"
-
-    def metadata_proxy(d):
-        res = ReadOnlyDict()
-        res.data.update(d)  # We blocked update, so we have to do it like this.
-        return res
-
-    def just_warn(*args, **kw):  # pragma: no cover
-        """
-        We only warn on Python 3 because we are not aware of any concrete
-        consequences of not setting the cell on Python 2.
-        """
-
-else:  # Python 3 and later.
-    from collections.abc import Mapping, Sequence  # noqa
-
-    def just_warn(*args, **kw):
-        """
-        We only warn on Python 3 because we are not aware of any concrete
-        consequences of not setting the cell on Python 2.
-        """
-        warnings.warn(
-            "Running interpreter doesn't sufficiently support code object "
-            "introspection.  Some features like bare super() or accessing "
-            "__class__ will not work with slotted classes.",
-            RuntimeWarning,
-            stacklevel=2,
-        )
-
-    def isclass(klass):
-        return isinstance(klass, type)
-
-    TYPE = "class"
-
-    def iteritems(d):
-        return d.items()
-
-    new_class = types.new_class
-
-    def metadata_proxy(d):
-        return types.MappingProxyType(dict(d))
-
-
-def make_set_closure_cell():
-    """Return a function of two arguments (cell, value) which sets
-    the value stored in the closure cell `cell` to `value`.
-    """
-    # pypy makes this easy. (It also supports the logic below, but
-    # why not do the easy/fast thing?)
-    if PYPY:
-
-        def set_closure_cell(cell, value):
-            cell.__setstate__((value,))
-
-        return set_closure_cell
-
-    # Otherwise gotta do it the hard way.
-
-    # Create a function that will set its first cellvar to `value`.
-    def set_first_cellvar_to(value):
-        x = value
-        return
-
-        # This function will be eliminated as dead code, but
-        # not before its reference to `x` forces `x` to be
-        # represented as a closure cell rather than a local.
-        def force_x_to_be_a_cell():  # pragma: no cover
-            return x
-
-    try:
-        # Extract the code object and make sure our assumptions about
-        # the closure behavior are correct.
-        if PY2:
-            co = set_first_cellvar_to.func_code
-        else:
-            co = set_first_cellvar_to.__code__
-        if co.co_cellvars != ("x",) or co.co_freevars != ():
-            raise AssertionError  # pragma: no cover
-
-        # Convert this code object to a code object that sets the
-        # function's first _freevar_ (not cellvar) to the argument.
-        if sys.version_info >= (3, 8):
-            # CPython 3.8+ has an incompatible CodeType signature
-            # (added a posonlyargcount argument) but also added
-            # CodeType.replace() to do this without counting parameters.
-            set_first_freevar_code = co.replace(
-                co_cellvars=co.co_freevars, co_freevars=co.co_cellvars
-            )
-        else:
-            args = [co.co_argcount]
-            if not PY2:
-                args.append(co.co_kwonlyargcount)
-            args.extend(
-                [
-                    co.co_nlocals,
-                    co.co_stacksize,
-                    co.co_flags,
-                    co.co_code,
-                    co.co_consts,
-                    co.co_names,
-                    co.co_varnames,
-                    co.co_filename,
-                    co.co_name,
-                    co.co_firstlineno,
-                    co.co_lnotab,
-                    # These two arguments are reversed:
-                    co.co_cellvars,
-                    co.co_freevars,
-                ]
-            )
-            set_first_freevar_code = types.CodeType(*args)
-
-        def set_closure_cell(cell, value):
-            # Create a function using the set_first_freevar_code,
-            # whose first closure cell is `cell`. Calling it will
-            # change the value of that cell.
-            setter = types.FunctionType(
-                set_first_freevar_code, {}, "setter", (), (cell,)
-            )
-            # And call it to set the cell.
-            setter(value)
-
-        # Make sure it works on this interpreter:
-        def make_func_with_cell():
-            x = None
-
-            def func():
-                return x  # pragma: no cover
-
-            return func
-
-        if PY2:
-            cell = make_func_with_cell().func_closure[0]
-        else:
-            cell = make_func_with_cell().__closure__[0]
-        set_closure_cell(cell, 100)
-        if cell.cell_contents != 100:
-            raise AssertionError  # pragma: no cover
-
-    except Exception:
-        return just_warn
-    else:
-        return set_closure_cell
-
-
-set_closure_cell = make_set_closure_cell()
-
-# Thread-local global to track attrs instances which are already being repr'd.
-# This is needed because there is no other (thread-safe) way to pass info
-# about the instances that are already being repr'd through the call stack
-# in order to ensure we don't perform infinite recursion.
-#
-# For instance, if an instance contains a dict which contains that instance,
-# we need to know that we're already repr'ing the outside instance from within
-# the dict's repr() call.
-#
-# This lives here rather than in _make.py so that the functions in _make.py
-# don't have a direct reference to the thread-local in their globals dict.
-# If they have such a reference, it breaks cloudpickle.
-repr_context = threading.local()

client/ayon_core/vendor/python/python_2/attr/_config.py

@@ -1,33 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-
-__all__ = ["set_run_validators", "get_run_validators"]
-
-_run_validators = True
-
-
-def set_run_validators(run):
-    """
-    Set whether or not validators are run.  By default, they are run.
-
-    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
-        moved to new ``attrs`` namespace. Use `attrs.validators.set_disabled()`
-        instead.
-    """
-    if not isinstance(run, bool):
-        raise TypeError("'run' must be bool.")
-    global _run_validators
-    _run_validators = run
-
-
-def get_run_validators():
-    """
-    Return whether or not validators are run.
-
-    .. deprecated:: 21.3.0 It will not be removed, but it also will not be
-        moved to new ``attrs`` namespace. Use `attrs.validators.get_disabled()`
-        instead.
-    """
-    return _run_validators

client/ayon_core/vendor/python/python_2/attr/_funcs.py

@@ -1,422 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-import copy
-
-from ._compat import iteritems
-from ._make import NOTHING, _obj_setattr, fields
-from .exceptions import AttrsAttributeNotFoundError
-
-
-def asdict(
-    inst,
-    recurse=True,
-    filter=None,
-    dict_factory=dict,
-    retain_collection_types=False,
-    value_serializer=None,
-):
-    """
-    Return the ``attrs`` attribute values of *inst* as a dict.
-
-    Optionally recurse into other ``attrs``-decorated classes.
-
-    :param inst: Instance of an ``attrs``-decorated class.
-    :param bool recurse: Recurse into classes that are also
-        ``attrs``-decorated.
-    :param callable filter: A callable whose return code determines whether an
-        attribute or element is included (``True``) or dropped (``False``).  Is
-        called with the `attrs.Attribute` as the first argument and the
-        value as the second argument.
-    :param callable dict_factory: A callable to produce dictionaries from.  For
-        example, to produce ordered dictionaries instead of normal Python
-        dictionaries, pass in ``collections.OrderedDict``.
-    :param bool retain_collection_types: Do not convert to ``list`` when
-        encountering an attribute whose type is ``tuple`` or ``set``.  Only
-        meaningful if ``recurse`` is ``True``.
-    :param Optional[callable] value_serializer: A hook that is called for every
-        attribute or dict key/value.  It receives the current instance, field
-        and value and must return the (updated) value.  The hook is run *after*
-        the optional *filter* has been applied.
-
-    :rtype: return type of *dict_factory*
-
-    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
-        class.
-
-    ..  versionadded:: 16.0.0 *dict_factory*
-    ..  versionadded:: 16.1.0 *retain_collection_types*
-    ..  versionadded:: 20.3.0 *value_serializer*
-    ..  versionadded:: 21.3.0 If a dict has a collection for a key, it is
-        serialized as a tuple.
-    """
-    attrs = fields(inst.__class__)
-    rv = dict_factory()
-    for a in attrs:
-        v = getattr(inst, a.name)
-        if filter is not None and not filter(a, v):
-            continue
-
-        if value_serializer is not None:
-            v = value_serializer(inst, a, v)
-
-        if recurse is True:
-            if has(v.__class__):
-                rv[a.name] = asdict(
-                    v,
-                    recurse=True,
-                    filter=filter,
-                    dict_factory=dict_factory,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                )
-            elif isinstance(v, (tuple, list, set, frozenset)):
-                cf = v.__class__ if retain_collection_types is True else list
-                rv[a.name] = cf(
-                    [
-                        _asdict_anything(
-                            i,
-                            is_key=False,
-                            filter=filter,
-                            dict_factory=dict_factory,
-                            retain_collection_types=retain_collection_types,
-                            value_serializer=value_serializer,
-                        )
-                        for i in v
-                    ]
-                )
-            elif isinstance(v, dict):
-                df = dict_factory
-                rv[a.name] = df(
-                    (
-                        _asdict_anything(
-                            kk,
-                            is_key=True,
-                            filter=filter,
-                            dict_factory=df,
-                            retain_collection_types=retain_collection_types,
-                            value_serializer=value_serializer,
-                        ),
-                        _asdict_anything(
-                            vv,
-                            is_key=False,
-                            filter=filter,
-                            dict_factory=df,
-                            retain_collection_types=retain_collection_types,
-                            value_serializer=value_serializer,
-                        ),
-                    )
-                    for kk, vv in iteritems(v)
-                )
-            else:
-                rv[a.name] = v
-        else:
-            rv[a.name] = v
-    return rv
-
-
-def _asdict_anything(
-    val,
-    is_key,
-    filter,
-    dict_factory,
-    retain_collection_types,
-    value_serializer,
-):
-    """
-    ``asdict`` only works on attrs instances, this works on anything.
-    """
-    if getattr(val.__class__, "__attrs_attrs__", None) is not None:
-        # Attrs class.
-        rv = asdict(
-            val,
-            recurse=True,
-            filter=filter,
-            dict_factory=dict_factory,
-            retain_collection_types=retain_collection_types,
-            value_serializer=value_serializer,
-        )
-    elif isinstance(val, (tuple, list, set, frozenset)):
-        if retain_collection_types is True:
-            cf = val.__class__
-        elif is_key:
-            cf = tuple
-        else:
-            cf = list
-
-        rv = cf(
-            [
-                _asdict_anything(
-                    i,
-                    is_key=False,
-                    filter=filter,
-                    dict_factory=dict_factory,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                )
-                for i in val
-            ]
-        )
-    elif isinstance(val, dict):
-        df = dict_factory
-        rv = df(
-            (
-                _asdict_anything(
-                    kk,
-                    is_key=True,
-                    filter=filter,
-                    dict_factory=df,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                ),
-                _asdict_anything(
-                    vv,
-                    is_key=False,
-                    filter=filter,
-                    dict_factory=df,
-                    retain_collection_types=retain_collection_types,
-                    value_serializer=value_serializer,
-                ),
-            )
-            for kk, vv in iteritems(val)
-        )
-    else:
-        rv = val
-        if value_serializer is not None:
-            rv = value_serializer(None, None, rv)
-
-    return rv
-
-
-def astuple(
-    inst,
-    recurse=True,
-    filter=None,
-    tuple_factory=tuple,
-    retain_collection_types=False,
-):
-    """
-    Return the ``attrs`` attribute values of *inst* as a tuple.
-
-    Optionally recurse into other ``attrs``-decorated classes.
-
-    :param inst: Instance of an ``attrs``-decorated class.
-    :param bool recurse: Recurse into classes that are also
-        ``attrs``-decorated.
-    :param callable filter: A callable whose return code determines whether an
-        attribute or element is included (``True``) or dropped (``False``).  Is
-        called with the `attrs.Attribute` as the first argument and the
-        value as the second argument.
-    :param callable tuple_factory: A callable to produce tuples from.  For
-        example, to produce lists instead of tuples.
-    :param bool retain_collection_types: Do not convert to ``list``
-        or ``dict`` when encountering an attribute which type is
-        ``tuple``, ``dict`` or ``set``.  Only meaningful if ``recurse`` is
-        ``True``.
-
-    :rtype: return type of *tuple_factory*
-
-    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
-        class.
-
-    ..  versionadded:: 16.2.0
-    """
-    attrs = fields(inst.__class__)
-    rv = []
-    retain = retain_collection_types  # Very long. :/
-    for a in attrs:
-        v = getattr(inst, a.name)
-        if filter is not None and not filter(a, v):
-            continue
-        if recurse is True:
-            if has(v.__class__):
-                rv.append(
-                    astuple(
-                        v,
-                        recurse=True,
-                        filter=filter,
-                        tuple_factory=tuple_factory,
-                        retain_collection_types=retain,
-                    )
-                )
-            elif isinstance(v, (tuple, list, set, frozenset)):
-                cf = v.__class__ if retain is True else list
-                rv.append(
-                    cf(
-                        [
-                            astuple(
-                                j,
-                                recurse=True,
-                                filter=filter,
-                                tuple_factory=tuple_factory,
-                                retain_collection_types=retain,
-                            )
-                            if has(j.__class__)
-                            else j
-                            for j in v
-                        ]
-                    )
-                )
-            elif isinstance(v, dict):
-                df = v.__class__ if retain is True else dict
-                rv.append(
-                    df(
-                        (
-                            astuple(
-                                kk,
-                                tuple_factory=tuple_factory,
-                                retain_collection_types=retain,
-                            )
-                            if has(kk.__class__)
-                            else kk,
-                            astuple(
-                                vv,
-                                tuple_factory=tuple_factory,
-                                retain_collection_types=retain,
-                            )
-                            if has(vv.__class__)
-                            else vv,
-                        )
-                        for kk, vv in iteritems(v)
-                    )
-                )
-            else:
-                rv.append(v)
-        else:
-            rv.append(v)
-
-    return rv if tuple_factory is list else tuple_factory(rv)
-
-
-def has(cls):
-    """
-    Check whether *cls* is a class with ``attrs`` attributes.
-
-    :param type cls: Class to introspect.
-    :raise TypeError: If *cls* is not a class.
-
-    :rtype: bool
-    """
-    return getattr(cls, "__attrs_attrs__", None) is not None
-
-
-def assoc(inst, **changes):
-    """
-    Copy *inst* and apply *changes*.
-
-    :param inst: Instance of a class with ``attrs`` attributes.
-    :param changes: Keyword changes in the new copy.
-
-    :return: A copy of inst with *changes* incorporated.
-
-    :raise attr.exceptions.AttrsAttributeNotFoundError: If *attr_name* couldn't
-        be found on *cls*.
-    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
-        class.
-
-    ..  deprecated:: 17.1.0
-        Use `attrs.evolve` instead if you can.
-        This function will not be removed du to the slightly different approach
-        compared to `attrs.evolve`.
-    """
-    import warnings
-
-    warnings.warn(
-        "assoc is deprecated and will be removed after 2018/01.",
-        DeprecationWarning,
-        stacklevel=2,
-    )
-    new = copy.copy(inst)
-    attrs = fields(inst.__class__)
-    for k, v in iteritems(changes):
-        a = getattr(attrs, k, NOTHING)
-        if a is NOTHING:
-            raise AttrsAttributeNotFoundError(
-                "{k} is not an attrs attribute on {cl}.".format(
-                    k=k, cl=new.__class__
-                )
-            )
-        _obj_setattr(new, k, v)
-    return new
-
-
-def evolve(inst, **changes):
-    """
-    Create a new instance, based on *inst* with *changes* applied.
-
-    :param inst: Instance of a class with ``attrs`` attributes.
-    :param changes: Keyword changes in the new copy.
-
-    :return: A copy of inst with *changes* incorporated.
-
-    :raise TypeError: If *attr_name* couldn't be found in the class
-        ``__init__``.
-    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
-        class.
-
-    ..  versionadded:: 17.1.0
-    """
-    cls = inst.__class__
-    attrs = fields(cls)
-    for a in attrs:
-        if not a.init:
-            continue
-        attr_name = a.name  # To deal with private attributes.
-        init_name = attr_name if attr_name[0] != "_" else attr_name[1:]
-        if init_name not in changes:
-            changes[init_name] = getattr(inst, attr_name)
-
-    return cls(**changes)
-
-
-def resolve_types(cls, globalns=None, localns=None, attribs=None):
-    """
-    Resolve any strings and forward annotations in type annotations.
-
-    This is only required if you need concrete types in `Attribute`'s *type*
-    field. In other words, you don't need to resolve your types if you only
-    use them for static type checking.
-
-    With no arguments, names will be looked up in the module in which the class
-    was created. If this is not what you want, e.g. if the name only exists
-    inside a method, you may pass *globalns* or *localns* to specify other
-    dictionaries in which to look up these names. See the docs of
-    `typing.get_type_hints` for more details.
-
-    :param type cls: Class to resolve.
-    :param Optional[dict] globalns: Dictionary containing global variables.
-    :param Optional[dict] localns: Dictionary containing local variables.
-    :param Optional[list] attribs: List of attribs for the given class.
-        This is necessary when calling from inside a ``field_transformer``
-        since *cls* is not an ``attrs`` class yet.
-
-    :raise TypeError: If *cls* is not a class.
-    :raise attr.exceptions.NotAnAttrsClassError: If *cls* is not an ``attrs``
-        class and you didn't pass any attribs.
-    :raise NameError: If types cannot be resolved because of missing variables.
-
-    :returns: *cls* so you can use this function also as a class decorator.
-        Please note that you have to apply it **after** `attrs.define`. That
-        means the decorator has to come in the line **before** `attrs.define`.
-
-    ..  versionadded:: 20.1.0
-    ..  versionadded:: 21.1.0 *attribs*
-
-    """
-    # Since calling get_type_hints is expensive we cache whether we've
-    # done it already.
-    if getattr(cls, "__attrs_types_resolved__", None) != cls:
-        import typing
-
-        hints = typing.get_type_hints(cls, globalns=globalns, localns=localns)
-        for field in fields(cls) if attribs is None else attribs:
-            if field.name in hints:
-                # Since fields have been frozen we must work around it.
-                _obj_setattr(field, "type", hints[field.name])
-        # We store the class we resolved so that subclasses know they haven't
-        # been resolved.
-        cls.__attrs_types_resolved__ = cls
-
-    # Return the class so you can use it as a decorator too.
-    return cls

client/ayon_core/vendor/python/python_2/attr/_next_gen.py

@@ -1,216 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-These are Python 3.6+-only and keyword-only APIs that call `attr.s` and
-`attr.ib` with different default values.
-"""
-
-
-from functools import partial
-
-from . import setters
-from ._funcs import asdict as _asdict
-from ._funcs import astuple as _astuple
-from ._make import (
-    NOTHING,
-    _frozen_setattrs,
-    _ng_default_on_setattr,
-    attrib,
-    attrs,
-)
-from .exceptions import UnannotatedAttributeError
-
-
-def define(
-    maybe_cls=None,
-    *,
-    these=None,
-    repr=None,
-    hash=None,
-    init=None,
-    slots=True,
-    frozen=False,
-    weakref_slot=True,
-    str=False,
-    auto_attribs=None,
-    kw_only=False,
-    cache_hash=False,
-    auto_exc=True,
-    eq=None,
-    order=False,
-    auto_detect=True,
-    getstate_setstate=None,
-    on_setattr=None,
-    field_transformer=None,
-    match_args=True,
-):
-    r"""
-    Define an ``attrs`` class.
-
-    Differences to the classic `attr.s` that it uses underneath:
-
-    - Automatically detect whether or not *auto_attribs* should be `True`
-      (c.f. *auto_attribs* parameter).
-    - If *frozen* is `False`, run converters and validators when setting an
-      attribute by default.
-    - *slots=True* (see :term:`slotted classes` for potentially surprising
-      behaviors)
-    - *auto_exc=True*
-    - *auto_detect=True*
-    - *order=False*
-    - *match_args=True*
-    - Some options that were only relevant on Python 2 or were kept around for
-      backwards-compatibility have been removed.
-
-    Please note that these are all defaults and you can change them as you
-    wish.
-
-    :param Optional[bool] auto_attribs: If set to `True` or `False`, it behaves
-       exactly like `attr.s`. If left `None`, `attr.s` will try to guess:
-
-       1. If any attributes are annotated and no unannotated `attrs.fields`\ s
-          are found, it assumes *auto_attribs=True*.
-       2. Otherwise it assumes *auto_attribs=False* and tries to collect
-          `attrs.fields`\ s.
-
-    For now, please refer to `attr.s` for the rest of the parameters.
-
-    .. versionadded:: 20.1.0
-    .. versionchanged:: 21.3.0 Converters are also run ``on_setattr``.
-    """
-
-    def do_it(cls, auto_attribs):
-        return attrs(
-            maybe_cls=cls,
-            these=these,
-            repr=repr,
-            hash=hash,
-            init=init,
-            slots=slots,
-            frozen=frozen,
-            weakref_slot=weakref_slot,
-            str=str,
-            auto_attribs=auto_attribs,
-            kw_only=kw_only,
-            cache_hash=cache_hash,
-            auto_exc=auto_exc,
-            eq=eq,
-            order=order,
-            auto_detect=auto_detect,
-            collect_by_mro=True,
-            getstate_setstate=getstate_setstate,
-            on_setattr=on_setattr,
-            field_transformer=field_transformer,
-            match_args=match_args,
-        )
-
-    def wrap(cls):
-        """
-        Making this a wrapper ensures this code runs during class creation.
-
-        We also ensure that frozen-ness of classes is inherited.
-        """
-        nonlocal frozen, on_setattr
-
-        had_on_setattr = on_setattr not in (None, setters.NO_OP)
-
-        # By default, mutable classes convert & validate on setattr.
-        if frozen is False and on_setattr is None:
-            on_setattr = _ng_default_on_setattr
-
-        # However, if we subclass a frozen class, we inherit the immutability
-        # and disable on_setattr.
-        for base_cls in cls.__bases__:
-            if base_cls.__setattr__ is _frozen_setattrs:
-                if had_on_setattr:
-                    raise ValueError(
-                        "Frozen classes can't use on_setattr "
-                        "(frozen-ness was inherited)."
-                    )
-
-                on_setattr = setters.NO_OP
-                break
-
-        if auto_attribs is not None:
-            return do_it(cls, auto_attribs)
-
-        try:
-            return do_it(cls, True)
-        except UnannotatedAttributeError:
-            return do_it(cls, False)
-
-    # maybe_cls's type depends on the usage of the decorator.  It's a class
-    # if it's used as `@attrs` but ``None`` if used as `@attrs()`.
-    if maybe_cls is None:
-        return wrap
-    else:
-        return wrap(maybe_cls)
-
-
-mutable = define
-frozen = partial(define, frozen=True, on_setattr=None)
-
-
-def field(
-    *,
-    default=NOTHING,
-    validator=None,
-    repr=True,
-    hash=None,
-    init=True,
-    metadata=None,
-    converter=None,
-    factory=None,
-    kw_only=False,
-    eq=None,
-    order=None,
-    on_setattr=None,
-):
-    """
-    Identical to `attr.ib`, except keyword-only and with some arguments
-    removed.
-
-    .. versionadded:: 20.1.0
-    """
-    return attrib(
-        default=default,
-        validator=validator,
-        repr=repr,
-        hash=hash,
-        init=init,
-        metadata=metadata,
-        converter=converter,
-        factory=factory,
-        kw_only=kw_only,
-        eq=eq,
-        order=order,
-        on_setattr=on_setattr,
-    )
-
-
-def asdict(inst, *, recurse=True, filter=None, value_serializer=None):
-    """
-    Same as `attr.asdict`, except that collections types are always retained
-    and dict is always used as *dict_factory*.
-
-    .. versionadded:: 21.3.0
-    """
-    return _asdict(
-        inst=inst,
-        recurse=recurse,
-        filter=filter,
-        value_serializer=value_serializer,
-        retain_collection_types=True,
-    )
-
-
-def astuple(inst, *, recurse=True, filter=None):
-    """
-    Same as `attr.astuple`, except that collections types are always retained
-    and `tuple` is always used as the *tuple_factory*.
-
-    .. versionadded:: 21.3.0
-    """
-    return _astuple(
-        inst=inst, recurse=recurse, filter=filter, retain_collection_types=True
-    )

client/ayon_core/vendor/python/python_2/attr/_version_info.py

@@ -1,87 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-from functools import total_ordering
-
-from ._funcs import astuple
-from ._make import attrib, attrs
-
-
-@total_ordering
-@attrs(eq=False, order=False, slots=True, frozen=True)
-class VersionInfo(object):
-    """
-    A version object that can be compared to tuple of length 1--4:
-
-    >>> attr.VersionInfo(19, 1, 0, "final")  <= (19, 2)
-    True
-    >>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1)
-    True
-    >>> vi = attr.VersionInfo(19, 2, 0, "final")
-    >>> vi < (19, 1, 1)
-    False
-    >>> vi < (19,)
-    False
-    >>> vi == (19, 2,)
-    True
-    >>> vi == (19, 2, 1)
-    False
-
-    .. versionadded:: 19.2
-    """
-
-    year = attrib(type=int)
-    minor = attrib(type=int)
-    micro = attrib(type=int)
-    releaselevel = attrib(type=str)
-
-    @classmethod
-    def _from_version_string(cls, s):
-        """
-        Parse *s* and return a _VersionInfo.
-        """
-        v = s.split(".")
-        if len(v) == 3:
-            v.append("final")
-
-        return cls(
-            year=int(v[0]), minor=int(v[1]), micro=int(v[2]), releaselevel=v[3]
-        )
-
-    def _ensure_tuple(self, other):
-        """
-        Ensure *other* is a tuple of a valid length.
-
-        Returns a possibly transformed *other* and ourselves as a tuple of
-        the same length as *other*.
-        """
-
-        if self.__class__ is other.__class__:
-            other = astuple(other)
-
-        if not isinstance(other, tuple):
-            raise NotImplementedError
-
-        if not (1 <= len(other) <= 4):
-            raise NotImplementedError
-
-        return astuple(self)[: len(other)], other
-
-    def __eq__(self, other):
-        try:
-            us, them = self._ensure_tuple(other)
-        except NotImplementedError:
-            return NotImplemented
-
-        return us == them
-
-    def __lt__(self, other):
-        try:
-            us, them = self._ensure_tuple(other)
-        except NotImplementedError:
-            return NotImplemented
-
-        # Since alphabetically "dev0" < "final" < "post1" < "post2", we don't
-        # have to do anything special with releaselevel for now.
-        return us < them

client/ayon_core/vendor/python/python_2/attr/_version_info.pyi

@@ -1,9 +0,0 @@
-class VersionInfo:
-    @property
-    def year(self) -> int: ...
-    @property
-    def minor(self) -> int: ...
-    @property
-    def micro(self) -> int: ...
-    @property
-    def releaselevel(self) -> str: ...

client/ayon_core/vendor/python/python_2/attr/converters.py

@@ -1,155 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful converters.
-"""
-
-from __future__ import absolute_import, division, print_function
-
-from ._compat import PY2
-from ._make import NOTHING, Factory, pipe
-
-
-if not PY2:
-    import inspect
-    import typing
-
-
-__all__ = [
-    "default_if_none",
-    "optional",
-    "pipe",
-    "to_bool",
-]
-
-
-def optional(converter):
-    """
-    A converter that allows an attribute to be optional. An optional attribute
-    is one which can be set to ``None``.
-
-    Type annotations will be inferred from the wrapped converter's, if it
-    has any.
-
-    :param callable converter: the converter that is used for non-``None``
-        values.
-
-    .. versionadded:: 17.1.0
-    """
-
-    def optional_converter(val):
-        if val is None:
-            return None
-        return converter(val)
-
-    if not PY2:
-        sig = None
-        try:
-            sig = inspect.signature(converter)
-        except (ValueError, TypeError):  # inspect failed
-            pass
-        if sig:
-            params = list(sig.parameters.values())
-            if params and params[0].annotation is not inspect.Parameter.empty:
-                optional_converter.__annotations__["val"] = typing.Optional[
-                    params[0].annotation
-                ]
-            if sig.return_annotation is not inspect.Signature.empty:
-                optional_converter.__annotations__["return"] = typing.Optional[
-                    sig.return_annotation
-                ]
-
-    return optional_converter
-
-
-def default_if_none(default=NOTHING, factory=None):
-    """
-    A converter that allows to replace ``None`` values by *default* or the
-    result of *factory*.
-
-    :param default: Value to be used if ``None`` is passed. Passing an instance
-       of `attrs.Factory` is supported, however the ``takes_self`` option
-       is *not*.
-    :param callable factory: A callable that takes no parameters whose result
-       is used if ``None`` is passed.
-
-    :raises TypeError: If **neither** *default* or *factory* is passed.
-    :raises TypeError: If **both** *default* and *factory* are passed.
-    :raises ValueError: If an instance of `attrs.Factory` is passed with
-       ``takes_self=True``.
-
-    .. versionadded:: 18.2.0
-    """
-    if default is NOTHING and factory is None:
-        raise TypeError("Must pass either `default` or `factory`.")
-
-    if default is not NOTHING and factory is not None:
-        raise TypeError(
-            "Must pass either `default` or `factory` but not both."
-        )
-
-    if factory is not None:
-        default = Factory(factory)
-
-    if isinstance(default, Factory):
-        if default.takes_self:
-            raise ValueError(
-                "`takes_self` is not supported by default_if_none."
-            )
-
-        def default_if_none_converter(val):
-            if val is not None:
-                return val
-
-            return default.factory()
-
-    else:
-
-        def default_if_none_converter(val):
-            if val is not None:
-                return val
-
-            return default
-
-    return default_if_none_converter
-
-
-def to_bool(val):
-    """
-    Convert "boolean" strings (e.g., from env. vars.) to real booleans.
-
-    Values mapping to :code:`True`:
-
-    - :code:`True`
-    - :code:`"true"` / :code:`"t"`
-    - :code:`"yes"` / :code:`"y"`
-    - :code:`"on"`
-    - :code:`"1"`
-    - :code:`1`
-
-    Values mapping to :code:`False`:
-
-    - :code:`False`
-    - :code:`"false"` / :code:`"f"`
-    - :code:`"no"` / :code:`"n"`
-    - :code:`"off"`
-    - :code:`"0"`
-    - :code:`0`
-
-    :raises ValueError: for any other value.
-
-    .. versionadded:: 21.3.0
-    """
-    if isinstance(val, str):
-        val = val.lower()
-    truthy = {True, "true", "t", "yes", "y", "on", "1", 1}
-    falsy = {False, "false", "f", "no", "n", "off", "0", 0}
-    try:
-        if val in truthy:
-            return True
-        if val in falsy:
-            return False
-    except TypeError:
-        # Raised when "val" is not hashable (e.g., lists)
-        pass
-    raise ValueError("Cannot convert value to bool: {}".format(val))

client/ayon_core/vendor/python/python_2/attr/converters.pyi

@@ -1,13 +0,0 @@
-from typing import Callable, Optional, TypeVar, overload
-
-from . import _ConverterType
-
-_T = TypeVar("_T")
-
-def pipe(*validators: _ConverterType) -> _ConverterType: ...
-def optional(converter: _ConverterType) -> _ConverterType: ...
-@overload
-def default_if_none(default: _T) -> _ConverterType: ...
-@overload
-def default_if_none(*, factory: Callable[[], _T]) -> _ConverterType: ...
-def to_bool(val: str) -> bool: ...

client/ayon_core/vendor/python/python_2/attr/exceptions.py

@@ -1,94 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from __future__ import absolute_import, division, print_function
-
-
-class FrozenError(AttributeError):
-    """
-    A frozen/immutable instance or attribute have been attempted to be
-    modified.
-
-    It mirrors the behavior of ``namedtuples`` by using the same error message
-    and subclassing `AttributeError`.
-
-    .. versionadded:: 20.1.0
-    """
-
-    msg = "can't set attribute"
-    args = [msg]
-
-
-class FrozenInstanceError(FrozenError):
-    """
-    A frozen instance has been attempted to be modified.
-
-    .. versionadded:: 16.1.0
-    """
-
-
-class FrozenAttributeError(FrozenError):
-    """
-    A frozen attribute has been attempted to be modified.
-
-    .. versionadded:: 20.1.0
-    """
-
-
-class AttrsAttributeNotFoundError(ValueError):
-    """
-    An ``attrs`` function couldn't find an attribute that the user asked for.
-
-    .. versionadded:: 16.2.0
-    """
-
-
-class NotAnAttrsClassError(ValueError):
-    """
-    A non-``attrs`` class has been passed into an ``attrs`` function.
-
-    .. versionadded:: 16.2.0
-    """
-
-
-class DefaultAlreadySetError(RuntimeError):
-    """
-    A default has been set using ``attr.ib()`` and is attempted to be reset
-    using the decorator.
-
-    .. versionadded:: 17.1.0
-    """
-
-
-class UnannotatedAttributeError(RuntimeError):
-    """
-    A class with ``auto_attribs=True`` has an ``attr.ib()`` without a type
-    annotation.
-
-    .. versionadded:: 17.3.0
-    """
-
-
-class PythonTooOldError(RuntimeError):
-    """
-    It was attempted to use an ``attrs`` feature that requires a newer Python
-    version.
-
-    .. versionadded:: 18.2.0
-    """
-
-
-class NotCallableError(TypeError):
-    """
-    A ``attr.ib()`` requiring a callable has been set with a value
-    that is not callable.
-
-    .. versionadded:: 19.2.0
-    """
-
-    def __init__(self, msg, value):
-        super(TypeError, self).__init__(msg, value)
-        self.msg = msg
-        self.value = value
-
-    def __str__(self):
-        return str(self.msg)

client/ayon_core/vendor/python/python_2/attr/exceptions.pyi

@@ -1,17 +0,0 @@
-from typing import Any
-
-class FrozenError(AttributeError):
-    msg: str = ...
-
-class FrozenInstanceError(FrozenError): ...
-class FrozenAttributeError(FrozenError): ...
-class AttrsAttributeNotFoundError(ValueError): ...
-class NotAnAttrsClassError(ValueError): ...
-class DefaultAlreadySetError(RuntimeError): ...
-class UnannotatedAttributeError(RuntimeError): ...
-class PythonTooOldError(RuntimeError): ...
-
-class NotCallableError(TypeError):
-    msg: str = ...
-    value: Any = ...
-    def __init__(self, msg: str, value: Any) -> None: ...

client/ayon_core/vendor/python/python_2/attr/filters.py

@@ -1,54 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful filters for `attr.asdict`.
-"""
-
-from __future__ import absolute_import, division, print_function
-
-from ._compat import isclass
-from ._make import Attribute
-
-
-def _split_what(what):
-    """
-    Returns a tuple of `frozenset`s of classes and attributes.
-    """
-    return (
-        frozenset(cls for cls in what if isclass(cls)),
-        frozenset(cls for cls in what if isinstance(cls, Attribute)),
-    )
-
-
-def include(*what):
-    """
-    Include *what*.
-
-    :param what: What to include.
-    :type what: `list` of `type` or `attrs.Attribute`\\ s
-
-    :rtype: `callable`
-    """
-    cls, attrs = _split_what(what)
-
-    def include_(attribute, value):
-        return value.__class__ in cls or attribute in attrs
-
-    return include_
-
-
-def exclude(*what):
-    """
-    Exclude *what*.
-
-    :param what: What to exclude.
-    :type what: `list` of classes or `attrs.Attribute`\\ s.
-
-    :rtype: `callable`
-    """
-    cls, attrs = _split_what(what)
-
-    def exclude_(attribute, value):
-        return value.__class__ not in cls and attribute not in attrs
-
-    return exclude_

client/ayon_core/vendor/python/python_2/attr/filters.pyi

@@ -1,6 +0,0 @@
-from typing import Any, Union
-
-from . import Attribute, _FilterType
-
-def include(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...
-def exclude(*what: Union[type, Attribute[Any]]) -> _FilterType[Any]: ...

client/ayon_core/vendor/python/python_2/attr/setters.py

@@ -1,79 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly used hooks for on_setattr.
-"""
-
-from __future__ import absolute_import, division, print_function
-
-from . import _config
-from .exceptions import FrozenAttributeError
-
-
-def pipe(*setters):
-    """
-    Run all *setters* and return the return value of the last one.
-
-    .. versionadded:: 20.1.0
-    """
-
-    def wrapped_pipe(instance, attrib, new_value):
-        rv = new_value
-
-        for setter in setters:
-            rv = setter(instance, attrib, rv)
-
-        return rv
-
-    return wrapped_pipe
-
-
-def frozen(_, __, ___):
-    """
-    Prevent an attribute to be modified.
-
-    .. versionadded:: 20.1.0
-    """
-    raise FrozenAttributeError()
-
-
-def validate(instance, attrib, new_value):
-    """
-    Run *attrib*'s validator on *new_value* if it has one.
-
-    .. versionadded:: 20.1.0
-    """
-    if _config._run_validators is False:
-        return new_value
-
-    v = attrib.validator
-    if not v:
-        return new_value
-
-    v(instance, attrib, new_value)
-
-    return new_value
-
-
-def convert(instance, attrib, new_value):
-    """
-    Run *attrib*'s converter -- if it has one --  on *new_value* and return the
-    result.
-
-    .. versionadded:: 20.1.0
-    """
-    c = attrib.converter
-    if c:
-        return c(new_value)
-
-    return new_value
-
-
-NO_OP = object()
-"""
-Sentinel for disabling class-wide *on_setattr* hooks for certain attributes.
-
-Does not work in `pipe` or within lists.
-
-.. versionadded:: 20.1.0
-"""

client/ayon_core/vendor/python/python_2/attr/setters.pyi

@@ -1,19 +0,0 @@
-from typing import Any, NewType, NoReturn, TypeVar, cast
-
-from . import Attribute, _OnSetAttrType
-
-_T = TypeVar("_T")
-
-def frozen(
-    instance: Any, attribute: Attribute[Any], new_value: Any
-) -> NoReturn: ...
-def pipe(*setters: _OnSetAttrType) -> _OnSetAttrType: ...
-def validate(instance: Any, attribute: Attribute[_T], new_value: _T) -> _T: ...
-
-# convert is allowed to return Any, because they can be chained using pipe.
-def convert(
-    instance: Any, attribute: Attribute[Any], new_value: Any
-) -> Any: ...
-
-_NoOpType = NewType("_NoOpType", object)
-NO_OP: _NoOpType

client/ayon_core/vendor/python/python_2/attr/validators.py

@@ -1,561 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful validators.
-"""
-
-from __future__ import absolute_import, division, print_function
-
-import operator
-import re
-
-from contextlib import contextmanager
-
-from ._config import get_run_validators, set_run_validators
-from ._make import _AndValidator, and_, attrib, attrs
-from .exceptions import NotCallableError
-
-
-try:
-    Pattern = re.Pattern
-except AttributeError:  # Python <3.7 lacks a Pattern type.
-    Pattern = type(re.compile(""))
-
-
-__all__ = [
-    "and_",
-    "deep_iterable",
-    "deep_mapping",
-    "disabled",
-    "ge",
-    "get_disabled",
-    "gt",
-    "in_",
-    "instance_of",
-    "is_callable",
-    "le",
-    "lt",
-    "matches_re",
-    "max_len",
-    "optional",
-    "provides",
-    "set_disabled",
-]
-
-
-def set_disabled(disabled):
-    """
-    Globally disable or enable running validators.
-
-    By default, they are run.
-
-    :param disabled: If ``True``, disable running all validators.
-    :type disabled: bool
-
-    .. warning::
-
-        This function is not thread-safe!
-
-    .. versionadded:: 21.3.0
-    """
-    set_run_validators(not disabled)
-
-
-def get_disabled():
-    """
-    Return a bool indicating whether validators are currently disabled or not.
-
-    :return: ``True`` if validators are currently disabled.
-    :rtype: bool
-
-    .. versionadded:: 21.3.0
-    """
-    return not get_run_validators()
-
-
-@contextmanager
-def disabled():
-    """
-    Context manager that disables running validators within its context.
-
-    .. warning::
-
-        This context manager is not thread-safe!
-
-    .. versionadded:: 21.3.0
-    """
-    set_run_validators(False)
-    try:
-        yield
-    finally:
-        set_run_validators(True)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _InstanceOfValidator(object):
-    type = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not isinstance(value, self.type):
-            raise TypeError(
-                "'{name}' must be {type!r} (got {value!r} that is a "
-                "{actual!r}).".format(
-                    name=attr.name,
-                    type=self.type,
-                    actual=value.__class__,
-                    value=value,
-                ),
-                attr,
-                self.type,
-                value,
-            )
-
-    def __repr__(self):
-        return "<instance_of validator for type {type!r}>".format(
-            type=self.type
-        )
-
-
-def instance_of(type):
-    """
-    A validator that raises a `TypeError` if the initializer is called
-    with a wrong type for this particular attribute (checks are performed using
-    `isinstance` therefore it's also valid to pass a tuple of types).
-
-    :param type: The type to check for.
-    :type type: type or tuple of types
-
-    :raises TypeError: With a human readable error message, the attribute
-        (of type `attrs.Attribute`), the expected type, and the value it
-        got.
-    """
-    return _InstanceOfValidator(type)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MatchesReValidator(object):
-    pattern = attrib()
-    match_func = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not self.match_func(value):
-            raise ValueError(
-                "'{name}' must match regex {pattern!r}"
-                " ({value!r} doesn't)".format(
-                    name=attr.name, pattern=self.pattern.pattern, value=value
-                ),
-                attr,
-                self.pattern,
-                value,
-            )
-
-    def __repr__(self):
-        return "<matches_re validator for pattern {pattern!r}>".format(
-            pattern=self.pattern
-        )
-
-
-def matches_re(regex, flags=0, func=None):
-    r"""
-    A validator that raises `ValueError` if the initializer is called
-    with a string that doesn't match *regex*.
-
-    :param regex: a regex string or precompiled pattern to match against
-    :param int flags: flags that will be passed to the underlying re function
-        (default 0)
-    :param callable func: which underlying `re` function to call (options
-        are `re.fullmatch`, `re.search`, `re.match`, default
-        is ``None`` which means either `re.fullmatch` or an emulation of
-        it on Python 2). For performance reasons, they won't be used directly
-        but on a pre-`re.compile`\ ed pattern.
-
-    .. versionadded:: 19.2.0
-    .. versionchanged:: 21.3.0 *regex* can be a pre-compiled pattern.
-    """
-    fullmatch = getattr(re, "fullmatch", None)
-    valid_funcs = (fullmatch, None, re.search, re.match)
-    if func not in valid_funcs:
-        raise ValueError(
-            "'func' must be one of {}.".format(
-                ", ".join(
-                    sorted(
-                        e and e.__name__ or "None" for e in set(valid_funcs)
-                    )
-                )
-            )
-        )
-
-    if isinstance(regex, Pattern):
-        if flags:
-            raise TypeError(
-                "'flags' can only be used with a string pattern; "
-                "pass flags to re.compile() instead"
-            )
-        pattern = regex
-    else:
-        pattern = re.compile(regex, flags)
-
-    if func is re.match:
-        match_func = pattern.match
-    elif func is re.search:
-        match_func = pattern.search
-    elif fullmatch:
-        match_func = pattern.fullmatch
-    else:  # Python 2 fullmatch emulation (https://bugs.python.org/issue16203)
-        pattern = re.compile(
-            r"(?:{})\Z".format(pattern.pattern), pattern.flags
-        )
-        match_func = pattern.match
-
-    return _MatchesReValidator(pattern, match_func)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _ProvidesValidator(object):
-    interface = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not self.interface.providedBy(value):
-            raise TypeError(
-                "'{name}' must provide {interface!r} which {value!r} "
-                "doesn't.".format(
-                    name=attr.name, interface=self.interface, value=value
-                ),
-                attr,
-                self.interface,
-                value,
-            )
-
-    def __repr__(self):
-        return "<provides validator for interface {interface!r}>".format(
-            interface=self.interface
-        )
-
-
-def provides(interface):
-    """
-    A validator that raises a `TypeError` if the initializer is called
-    with an object that does not provide the requested *interface* (checks are
-    performed using ``interface.providedBy(value)`` (see `zope.interface
-    <https://zopeinterface.readthedocs.io/en/latest/>`_).
-
-    :param interface: The interface to check for.
-    :type interface: ``zope.interface.Interface``
-
-    :raises TypeError: With a human readable error message, the attribute
-        (of type `attrs.Attribute`), the expected interface, and the
-        value it got.
-    """
-    return _ProvidesValidator(interface)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _OptionalValidator(object):
-    validator = attrib()
-
-    def __call__(self, inst, attr, value):
-        if value is None:
-            return
-
-        self.validator(inst, attr, value)
-
-    def __repr__(self):
-        return "<optional validator for {what} or None>".format(
-            what=repr(self.validator)
-        )
-
-
-def optional(validator):
-    """
-    A validator that makes an attribute optional.  An optional attribute is one
-    which can be set to ``None`` in addition to satisfying the requirements of
-    the sub-validator.
-
-    :param validator: A validator (or a list of validators) that is used for
-        non-``None`` values.
-    :type validator: callable or `list` of callables.
-
-    .. versionadded:: 15.1.0
-    .. versionchanged:: 17.1.0 *validator* can be a list of validators.
-    """
-    if isinstance(validator, list):
-        return _OptionalValidator(_AndValidator(validator))
-    return _OptionalValidator(validator)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _InValidator(object):
-    options = attrib()
-
-    def __call__(self, inst, attr, value):
-        try:
-            in_options = value in self.options
-        except TypeError:  # e.g. `1 in "abc"`
-            in_options = False
-
-        if not in_options:
-            raise ValueError(
-                "'{name}' must be in {options!r} (got {value!r})".format(
-                    name=attr.name, options=self.options, value=value
-                )
-            )
-
-    def __repr__(self):
-        return "<in_ validator with options {options!r}>".format(
-            options=self.options
-        )
-
-
-def in_(options):
-    """
-    A validator that raises a `ValueError` if the initializer is called
-    with a value that does not belong in the options provided.  The check is
-    performed using ``value in options``.
-
-    :param options: Allowed options.
-    :type options: list, tuple, `enum.Enum`, ...
-
-    :raises ValueError: With a human readable error message, the attribute (of
-       type `attrs.Attribute`), the expected options, and the value it
-       got.
-
-    .. versionadded:: 17.1.0
-    """
-    return _InValidator(options)
-
-
-@attrs(repr=False, slots=False, hash=True)
-class _IsCallableValidator(object):
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not callable(value):
-            message = (
-                "'{name}' must be callable "
-                "(got {value!r} that is a {actual!r})."
-            )
-            raise NotCallableError(
-                msg=message.format(
-                    name=attr.name, value=value, actual=value.__class__
-                ),
-                value=value,
-            )
-
-    def __repr__(self):
-        return "<is_callable validator>"
-
-
-def is_callable():
-    """
-    A validator that raises a `attr.exceptions.NotCallableError` if the
-    initializer is called with a value for this particular attribute
-    that is not callable.
-
-    .. versionadded:: 19.1.0
-
-    :raises `attr.exceptions.NotCallableError`: With a human readable error
-        message containing the attribute (`attrs.Attribute`) name,
-        and the value it got.
-    """
-    return _IsCallableValidator()
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _DeepIterable(object):
-    member_validator = attrib(validator=is_callable())
-    iterable_validator = attrib(
-        default=None, validator=optional(is_callable())
-    )
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if self.iterable_validator is not None:
-            self.iterable_validator(inst, attr, value)
-
-        for member in value:
-            self.member_validator(inst, attr, member)
-
-    def __repr__(self):
-        iterable_identifier = (
-            ""
-            if self.iterable_validator is None
-            else " {iterable!r}".format(iterable=self.iterable_validator)
-        )
-        return (
-            "<deep_iterable validator for{iterable_identifier}"
-            " iterables of {member!r}>"
-        ).format(
-            iterable_identifier=iterable_identifier,
-            member=self.member_validator,
-        )
-
-
-def deep_iterable(member_validator, iterable_validator=None):
-    """
-    A validator that performs deep validation of an iterable.
-
-    :param member_validator: Validator to apply to iterable members
-    :param iterable_validator: Validator to apply to iterable itself
-        (optional)
-
-    .. versionadded:: 19.1.0
-
-    :raises TypeError: if any sub-validators fail
-    """
-    return _DeepIterable(member_validator, iterable_validator)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _DeepMapping(object):
-    key_validator = attrib(validator=is_callable())
-    value_validator = attrib(validator=is_callable())
-    mapping_validator = attrib(default=None, validator=optional(is_callable()))
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if self.mapping_validator is not None:
-            self.mapping_validator(inst, attr, value)
-
-        for key in value:
-            self.key_validator(inst, attr, key)
-            self.value_validator(inst, attr, value[key])
-
-    def __repr__(self):
-        return (
-            "<deep_mapping validator for objects mapping {key!r} to {value!r}>"
-        ).format(key=self.key_validator, value=self.value_validator)
-
-
-def deep_mapping(key_validator, value_validator, mapping_validator=None):
-    """
-    A validator that performs deep validation of a dictionary.
-
-    :param key_validator: Validator to apply to dictionary keys
-    :param value_validator: Validator to apply to dictionary values
-    :param mapping_validator: Validator to apply to top-level mapping
-        attribute (optional)
-
-    .. versionadded:: 19.1.0
-
-    :raises TypeError: if any sub-validators fail
-    """
-    return _DeepMapping(key_validator, value_validator, mapping_validator)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _NumberValidator(object):
-    bound = attrib()
-    compare_op = attrib()
-    compare_func = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if not self.compare_func(value, self.bound):
-            raise ValueError(
-                "'{name}' must be {op} {bound}: {value}".format(
-                    name=attr.name,
-                    op=self.compare_op,
-                    bound=self.bound,
-                    value=value,
-                )
-            )
-
-    def __repr__(self):
-        return "<Validator for x {op} {bound}>".format(
-            op=self.compare_op, bound=self.bound
-        )
-
-
-def lt(val):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a number larger or equal to *val*.
-
-    :param val: Exclusive upper bound for values
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, "<", operator.lt)
-
-
-def le(val):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a number greater than *val*.
-
-    :param val: Inclusive upper bound for values
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, "<=", operator.le)
-
-
-def ge(val):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a number smaller than *val*.
-
-    :param val: Inclusive lower bound for values
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, ">=", operator.ge)
-
-
-def gt(val):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a number smaller or equal to *val*.
-
-    :param val: Exclusive lower bound for values
-
-    .. versionadded:: 21.3.0
-    """
-    return _NumberValidator(val, ">", operator.gt)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MaxLengthValidator(object):
-    max_length = attrib()
-
-    def __call__(self, inst, attr, value):
-        """
-        We use a callable class to be able to change the ``__repr__``.
-        """
-        if len(value) > self.max_length:
-            raise ValueError(
-                "Length of '{name}' must be <= {max}: {len}".format(
-                    name=attr.name, max=self.max_length, len=len(value)
-                )
-            )
-
-    def __repr__(self):
-        return "<max_len validator for {max}>".format(max=self.max_length)
-
-
-def max_len(length):
-    """
-    A validator that raises `ValueError` if the initializer is called
-    with a string or iterable that is longer than *length*.
-
-    :param int length: Maximum length of the string or iterable
-
-    .. versionadded:: 21.3.0
-    """
-    return _MaxLengthValidator(length)

client/ayon_core/vendor/python/python_2/attr/validators.pyi

@@ -1,78 +0,0 @@
-from typing import (
-    Any,
-    AnyStr,
-    Callable,
-    Container,
-    ContextManager,
-    Iterable,
-    List,
-    Mapping,
-    Match,
-    Optional,
-    Pattern,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-    overload,
-)
-
-from . import _ValidatorType
-
-_T = TypeVar("_T")
-_T1 = TypeVar("_T1")
-_T2 = TypeVar("_T2")
-_T3 = TypeVar("_T3")
-_I = TypeVar("_I", bound=Iterable)
-_K = TypeVar("_K")
-_V = TypeVar("_V")
-_M = TypeVar("_M", bound=Mapping)
-
-def set_disabled(run: bool) -> None: ...
-def get_disabled() -> bool: ...
-def disabled() -> ContextManager[None]: ...
-
-# To be more precise on instance_of use some overloads.
-# If there are more than 3 items in the tuple then we fall back to Any
-@overload
-def instance_of(type: Type[_T]) -> _ValidatorType[_T]: ...
-@overload
-def instance_of(type: Tuple[Type[_T]]) -> _ValidatorType[_T]: ...
-@overload
-def instance_of(
-    type: Tuple[Type[_T1], Type[_T2]]
-) -> _ValidatorType[Union[_T1, _T2]]: ...
-@overload
-def instance_of(
-    type: Tuple[Type[_T1], Type[_T2], Type[_T3]]
-) -> _ValidatorType[Union[_T1, _T2, _T3]]: ...
-@overload
-def instance_of(type: Tuple[type, ...]) -> _ValidatorType[Any]: ...
-def provides(interface: Any) -> _ValidatorType[Any]: ...
-def optional(
-    validator: Union[_ValidatorType[_T], List[_ValidatorType[_T]]]
-) -> _ValidatorType[Optional[_T]]: ...
-def in_(options: Container[_T]) -> _ValidatorType[_T]: ...
-def and_(*validators: _ValidatorType[_T]) -> _ValidatorType[_T]: ...
-def matches_re(
-    regex: Union[Pattern[AnyStr], AnyStr],
-    flags: int = ...,
-    func: Optional[
-        Callable[[AnyStr, AnyStr, int], Optional[Match[AnyStr]]]
-    ] = ...,
-) -> _ValidatorType[AnyStr]: ...
-def deep_iterable(
-    member_validator: _ValidatorType[_T],
-    iterable_validator: Optional[_ValidatorType[_I]] = ...,
-) -> _ValidatorType[_I]: ...
-def deep_mapping(
-    key_validator: _ValidatorType[_K],
-    value_validator: _ValidatorType[_V],
-    mapping_validator: Optional[_ValidatorType[_M]] = ...,
-) -> _ValidatorType[_M]: ...
-def is_callable() -> _ValidatorType[_T]: ...
-def lt(val: _T) -> _ValidatorType[_T]: ...
-def le(val: _T) -> _ValidatorType[_T]: ...
-def ge(val: _T) -> _ValidatorType[_T]: ...
-def gt(val: _T) -> _ValidatorType[_T]: ...
-def max_len(length: int) -> _ValidatorType[_T]: ...

client/ayon_core/vendor/python/python_2/attrs/__init__.py

@@ -1,70 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr import (
-    NOTHING,
-    Attribute,
-    Factory,
-    __author__,
-    __copyright__,
-    __description__,
-    __doc__,
-    __email__,
-    __license__,
-    __title__,
-    __url__,
-    __version__,
-    __version_info__,
-    assoc,
-    cmp_using,
-    define,
-    evolve,
-    field,
-    fields,
-    fields_dict,
-    frozen,
-    has,
-    make_class,
-    mutable,
-    resolve_types,
-    validate,
-)
-from attr._next_gen import asdict, astuple
-
-from . import converters, exceptions, filters, setters, validators
-
-
-__all__ = [
-    "__author__",
-    "__copyright__",
-    "__description__",
-    "__doc__",
-    "__email__",
-    "__license__",
-    "__title__",
-    "__url__",
-    "__version__",
-    "__version_info__",
-    "asdict",
-    "assoc",
-    "astuple",
-    "Attribute",
-    "cmp_using",
-    "converters",
-    "define",
-    "evolve",
-    "exceptions",
-    "Factory",
-    "field",
-    "fields_dict",
-    "fields",
-    "filters",
-    "frozen",
-    "has",
-    "make_class",
-    "mutable",
-    "NOTHING",
-    "resolve_types",
-    "setters",
-    "validate",
-    "validators",
-]

client/ayon_core/vendor/python/python_2/attrs/__init__.pyi

@@ -1,63 +0,0 @@
-from typing import (
-    Any,
-    Callable,
-    Dict,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    Type,
-)
-
-# Because we need to type our own stuff, we have to make everything from
-# attr explicitly public too.
-from attr import __author__ as __author__
-from attr import __copyright__ as __copyright__
-from attr import __description__ as __description__
-from attr import __email__ as __email__
-from attr import __license__ as __license__
-from attr import __title__ as __title__
-from attr import __url__ as __url__
-from attr import __version__ as __version__
-from attr import __version_info__ as __version_info__
-from attr import _FilterType
-from attr import assoc as assoc
-from attr import Attribute as Attribute
-from attr import define as define
-from attr import evolve as evolve
-from attr import Factory as Factory
-from attr import exceptions as exceptions
-from attr import field as field
-from attr import fields as fields
-from attr import fields_dict as fields_dict
-from attr import frozen as frozen
-from attr import has as has
-from attr import make_class as make_class
-from attr import mutable as mutable
-from attr import NOTHING as NOTHING
-from attr import resolve_types as resolve_types
-from attr import setters as setters
-from attr import validate as validate
-from attr import validators as validators
-
-# TODO: see definition of attr.asdict/astuple
-def asdict(
-    inst: Any,
-    recurse: bool = ...,
-    filter: Optional[_FilterType[Any]] = ...,
-    dict_factory: Type[Mapping[Any, Any]] = ...,
-    retain_collection_types: bool = ...,
-    value_serializer: Optional[
-        Callable[[type, Attribute[Any], Any], Any]
-    ] = ...,
-    tuple_keys: bool = ...,
-) -> Dict[str, Any]: ...
-
-# TODO: add support for returning NamedTuple from the mypy plugin
-def astuple(
-    inst: Any,
-    recurse: bool = ...,
-    filter: Optional[_FilterType[Any]] = ...,
-    tuple_factory: Type[Sequence[Any]] = ...,
-    retain_collection_types: bool = ...,
-) -> Tuple[Any, ...]: ...

client/ayon_core/vendor/python/python_2/attrs/converters.py

@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.converters import *  # noqa

client/ayon_core/vendor/python/python_2/attrs/exceptions.py

@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.exceptions import *  # noqa

client/ayon_core/vendor/python/python_2/attrs/filters.py

@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.filters import *  # noqa

client/ayon_core/vendor/python/python_2/attrs/setters.py

@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.setters import *  # noqa

client/ayon_core/vendor/python/python_2/attrs/validators.py

@@ -1,3 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-from attr.validators import *  # noqa

client/ayon_core/vendor/python/python_2/backports/__init__.py

@@ -1 +0,0 @@
-__path__ = __import__('pkgutil').extend_path(__path__, __name__)