Merge branch 'develop' into feature/envs-in-roots

.github/workflows/pr_unittests.yaml

@@ -0,0 +1,31 @@
+name: 🧐 Run Unit Tests
+
+on:
+  push:
+    branches: [ develop ]
+  pull_request:
+    branches: [ develop ]
+
+  workflow_dispatch:
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event.pull_request.number}}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+  pull-requests: write
+
+jobs:
+  tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.9'
+      - name: Install requirements
+        run: ./tools/manage.sh create-env
+      - name: Run tests
+        run: ./tools/manage.sh run-tests

client/ayon_core/cli.py

@@ -8,7 +8,6 @@ from pathlib import Path
 import warnings
 
 import click
-import acre
 
 from ayon_core import AYON_CORE_ROOT
 from ayon_core.addon import AddonsManager
@@ -18,6 +17,11 @@ from ayon_core.lib import (
     is_running_from_build,
     Logger,
 )
+from ayon_core.lib.env_tools import (
+    parse_env_variables_structure,
+    compute_env_variables_structure,
+    merge_env_variables,
+)
 
 
 
@@ -235,19 +239,15 @@ def version(build):
 
 def _set_global_environments() -> None:
     """Set global AYON environments."""
-    general_env = get_general_environments()
+    # First resolve general environment
+    general_env = parse_env_variables_structure(get_general_environments())
 
-    # first resolve general environment because merge doesn't expect
-    # values to be list.
-    # TODO: switch to AYON environment functions
-    merged_env = acre.merge(
-        acre.compute(acre.parse(general_env), cleanup=False),
+    # Merge environments with current environments and update values
+    merged_env = merge_env_variables(
+        compute_env_variables_structure(general_env),
         dict(os.environ)
     )
-    env = acre.compute(
-        merged_env,
-        cleanup=False
-    )
+    env = compute_env_variables_structure(merged_env)
     os.environ.clear()
     os.environ.update(env)
 
@@ -263,8 +263,8 @@ def _set_addons_environments(addons_manager):
 
     # Merge environments with current environments and update values
     if module_envs := addons_manager.collect_global_environments():
-        parsed_envs = acre.parse(module_envs)
-        env = acre.merge(parsed_envs, dict(os.environ))
+        parsed_envs = parse_env_variables_structure(module_envs)
+        env = merge_env_variables(parsed_envs, dict(os.environ))
         os.environ.clear()
         os.environ.update(env)
 

client/ayon_core/lib/env_tools.py

@@ -1,7 +1,34 @@
+from __future__ import annotations
 import os
+import re
+import platform
+import typing
+import collections
+from string import Formatter
+from typing import Optional
+
+if typing.TYPE_CHECKING:
+    from typing import Union, Literal
+
+    PlatformName = Literal["windows", "linux", "darwin"]
+    EnvValue = Union[str, list[str], dict[str, str], dict[str, list[str]]]
 
 
-def env_value_to_bool(env_key=None, value=None, default=False):
+class CycleError(ValueError):
+    """Raised when a cycle is detected in dynamic env variables compute."""
+    pass
+
+
+class DynamicKeyClashError(Exception):
+    """Raised when dynamic key clashes with an existing key."""
+    pass
+
+
+def env_value_to_bool(
+    env_key: Optional[str] = None,
+    value: Optional[str] = None,
+    default: bool = False,
+) -> bool:
     """Convert environment variable value to boolean.
 
     Function is based on value of the environemt variable. Value is lowered
@@ -11,6 +38,7 @@ def env_value_to_bool(env_key=None, value=None, default=False):
         bool: If value match to one of ["true", "yes", "1"] result if True
             but if value match to ["false", "no", "0"] result is False else
             default value is returned.
+
     """
     if value is None and env_key is None:
         return default
@@ -27,18 +55,23 @@ def env_value_to_bool(env_key=None, value=None, default=False):
     return default
 
 
-def get_paths_from_environ(env_key=None, env_value=None, return_first=False):
+def get_paths_from_environ(
+    env_key: Optional[str] = None,
+    env_value: Optional[str] = None,
+    return_first: bool = False,
+) -> Optional[Union[str, list[str]]]:
     """Return existing paths from specific environment variable.
 
     Args:
-        env_key (str): Environment key where should look for paths.
-        env_value (str): Value of environment variable. Argument `env_key` is
-            skipped if this argument is entered.
+        env_key (Optional[str]): Environment key where should look for paths.
+        env_value (Optional[str]): Value of environment variable.
+            Argument `env_key` is skipped if this argument is entered.
         return_first (bool): Return first found value or return list of found
             paths. `None` or empty list returned if nothing found.
 
     Returns:
-        str, list, None: Result of found path/s.
+        Optional[Union[str, list[str]]]: Result of found path/s.
+
     """
     existing_paths = []
     if not env_key and not env_value:
@@ -69,3 +102,225 @@ def get_paths_from_environ(env_key=None, env_value=None, return_first=False):
         return None
     # Return all existing paths from environment variable
     return existing_paths
+
+
+def parse_env_variables_structure(
+    env: dict[str, EnvValue],
+    platform_name: Optional[PlatformName] = None
+) -> dict[str, str]:
+    """Parse environment for platform-specific values and paths as lists.
+
+    Args:
+        env (dict): The source environment to read.
+        platform_name (Optional[PlatformName]): Name of platform to parse for.
+            Defaults to current platform.
+
+    Returns:
+        dict: The flattened environment for a platform.
+
+    """
+    if platform_name is None:
+        platform_name = platform.system().lower()
+
+    # Separator based on OS 'os.pathsep' is ';' on Windows and ':' on Unix
+    sep = ";" if platform_name == "windows" else ":"
+
+    result = {}
+    for variable, value in env.items():
+        # Platform specific values
+        if isinstance(value, dict):
+            value = value.get(platform_name)
+
+        # Allow to have lists as values in the tool data
+        if isinstance(value, (list, tuple)):
+            value = sep.join(value)
+
+        if not value:
+            continue
+
+        if not isinstance(value, str):
+            raise TypeError(f"Expected 'str' got '{type(value)}'")
+
+        result[variable] = value
+
+    return result
+
+
+def _topological_sort(
+    dependencies: dict[str, set[str]]
+) -> tuple[list[str], list[str]]:
+    """Sort values subject to dependency constraints.
+
+    Args:
+        dependencies (dict[str, set[str]): Mapping of environment variable
+            keys to a set of keys they depend on.
+
+    Returns:
+        tuple[list[str], list[str]]: A tuple of two lists. The first list
+            contains the ordered keys in which order should be environment
+            keys filled, the second list contains the keys that would cause
+            cyclic fill of values.
+
+    """
+    num_heads = collections.defaultdict(int)  # num arrows pointing in
+    tails = collections.defaultdict(list)  # list of arrows going out
+    heads = []  # unique list of heads in order first seen
+    for head, tail_values in dependencies.items():
+        for tail_value in tail_values:
+            num_heads[tail_value] += 1
+            if head not in tails:
+                heads.append(head)
+            tails[head].append(tail_value)
+
+    ordered = [head for head in heads if head not in num_heads]
+    for head in ordered:
+        for tail in tails[head]:
+            num_heads[tail] -= 1
+            if not num_heads[tail]:
+                ordered.append(tail)
+    cyclic = [tail for tail, heads in num_heads.items() if heads]
+    return ordered, cyclic
+
+
+class _PartialFormatDict(dict):
+    """This supports partial formatting.
+
+    Missing keys are replaced with the return value of __missing__.
+
+    """
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        self._missing_template: str = "{{{key}}}"
+
+    def set_missing_template(self, template: str):
+        self._missing_template = template
+
+    def __missing__(self, key: str) -> str:
+        return self._missing_template.format(key=key)
+
+
+def _partial_format(
+    value: str,
+    data: dict[str, str],
+    missing_template: Optional[str] = None,
+) -> str:
+    """Return string `s` formatted by `data` allowing a partial format
+
+    Arguments:
+        value (str): The string that will be formatted
+        data (dict): The dictionary used to format with.
+        missing_template (Optional[str]): The template to use when a key is
+            missing from the data. If `None`, the key will remain unformatted.
+
+    Example:
+        >>> _partial_format("{d} {a} {b} {c} {d}", {'b': "and", 'd': "left"})
+        'left {a} and {c} left'
+
+    """
+
+    mapping = _PartialFormatDict(**data)
+    if missing_template is not None:
+        mapping.set_missing_template(missing_template)
+
+    formatter = Formatter()
+    try:
+        output = formatter.vformat(value, (), mapping)
+    except Exception:
+        r_token = re.compile(r"({.*?})")
+        output = value
+        for match in re.findall(r_token, value):
+            try:
+                output = re.sub(match, match.format(**data), output)
+            except (KeyError, ValueError, IndexError):
+                continue
+    return output
+
+
+def compute_env_variables_structure(
+    env: dict[str, str],
+    fill_dynamic_keys: bool = True,
+) -> dict[str, str]:
+    """Compute the result from recursive dynamic environment.
+
+    Note: Keys that are not present in the data will remain unformatted as the
+        original keys. So they can be formatted against the current user
+        environment when merging. So {"A": "{key}"} will remain {key} if not
+        present in the dynamic environment.
+
+    """
+    env = env.copy()
+
+    # Collect dependencies
+    dependencies = collections.defaultdict(set)
+    for key, value in env.items():
+        dependent_keys = re.findall("{(.+?)}", value)
+        for dependent_key in dependent_keys:
+            # Ignore reference to itself or key is not in env
+            if dependent_key != key and dependent_key in env:
+                dependencies[key].add(dependent_key)
+
+    ordered, cyclic = _topological_sort(dependencies)
+
+    # Check cycle
+    if cyclic:
+        raise CycleError(f"A cycle is detected on: {cyclic}")
+
+    # Format dynamic values
+    for key in reversed(ordered):
+        if key in env:
+            if not isinstance(env[key], str):
+                continue
+            data = env.copy()
+            data.pop(key)    # format without itself
+            env[key] = _partial_format(env[key], data=data)
+
+    # Format dynamic keys
+    if fill_dynamic_keys:
+        formatted = {}
+        for key, value in env.items():
+            if not isinstance(value, str):
+                formatted[key] = value
+                continue
+
+            new_key = _partial_format(key, data=env)
+            if new_key in formatted:
+                raise DynamicKeyClashError(
+                    f"Key clashes on: {new_key} (source: {key})"
+                )
+
+            formatted[new_key] = value
+        env = formatted
+
+    return env
+
+
+def merge_env_variables(
+    src_env: dict[str, str],
+    dst_env: dict[str, str],
+    missing_template: Optional[str] = None,
+) -> dict[str, str]:
+    """Merge the tools environment with the 'current_env'.
+
+    This finalizes the join with a current environment by formatting the
+    remainder of dynamic variables with that from the current environment.
+
+    Remaining missing variables result in an empty value.
+
+    Args:
+        src_env (dict): The dynamic environment
+        dst_env (dict): The target environment variables mapping to merge
+            the dynamic environment into.
+        missing_template (str): Argument passed to '_partial_format' during
+            merging. `None` should keep missing keys unchanged.
+
+    Returns:
+        dict[str, str]: The resulting environment after the merge.
+
+    """
+    result = dst_env.copy()
+    for key, value in src_env.items():
+        result[key] = _partial_format(
+            str(value), dst_env, missing_template
+        )
+
+    return result

client/ayon_core/lib/transcoding.py

@@ -53,7 +53,7 @@ IMAGE_EXTENSIONS = {
     ".kra", ".logluv", ".mng", ".miff", ".nrrd", ".ora",
     ".pam", ".pbm", ".pgm", ".ppm", ".pnm", ".pcx", ".pgf",
     ".pictor", ".png", ".psd", ".psb", ".psp", ".qtvr",
-    ".ras", ".rgbe", ".sgi", ".tga",
+    ".ras", ".rgbe", ".sgi", ".sxr", ".tga",
     ".tif", ".tiff", ".tiff/ep", ".tiff/it", ".ufo", ".ufp",
     ".wbmp", ".webp", ".xr", ".xt", ".xbm", ".xcf", ".xpm", ".xwd"
 }

client/ayon_core/pipeline/create/context.py

@@ -755,11 +755,19 @@ class CreateContext:
                 ).format(creator_class.host_name, self.host_name))
                 continue
 
-            creator = creator_class(
-                project_settings,
-                self,
-                self.headless
-            )
+            # TODO report initialization error
+            try:
+                creator = creator_class(
+                    project_settings,
+                    self,
+                    self.headless
+                )
+            except Exception:
+                self.log.error(
+                    f"Failed to initialize plugin: {creator_class}",
+                    exc_info=True
+                )
+                continue
 
             if not creator.enabled:
                 disabled_creators[creator_identifier] = creator

client/ayon_core/pipeline/workfile/workfile_template_builder.py

@@ -54,6 +54,7 @@ from ayon_core.pipeline.plugin_discover import (
 from ayon_core.pipeline.create import (
     discover_legacy_creator_plugins,
     CreateContext,
+    HiddenCreator,
 )
 
 _NOT_SET = object()
@@ -309,7 +310,13 @@ class AbstractTemplateBuilder(ABC):
         self._creators_by_name = creators_by_name
 
     def _collect_creators(self):
-        self._creators_by_name = dict(self.create_context.creators)
+        self._creators_by_name = {
+            identifier: creator
+            for identifier, creator
+            in self.create_context.manual_creators.items()
+            # Do not list HiddenCreator even though it is a 'manual creator'
+            if not isinstance(creator, HiddenCreator)
+        }
 
     def get_creators_by_name(self):
         if self._creators_by_name is None:

client/ayon_core/plugins/publish/collect_anatomy_instance_data.py

@@ -116,11 +116,11 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
 
         if not_found_folder_paths:
             joined_folder_paths = ", ".join(
-                ["\"{}\"".format(path) for path in not_found_folder_paths]
+                [f"\"{path}\"" for path in not_found_folder_paths]
+            )
+            self.log.warning(
+                f"Not found folder entities with paths {joined_folder_paths}."
             )
-            self.log.warning((
-                "Not found folder entities with paths \"{}\"."
-            ).format(joined_folder_paths))
 
     def fill_missing_task_entities(self, context, project_name):
         self.log.debug("Querying task entities for instances.")

client/ayon_core/plugins/publish/collect_otio_frame_ranges.py

@@ -1,78 +1,120 @@
+"""Plugin for collecting OTIO frame ranges and related timing information.
+
+This module contains a unified plugin that handles:
+- Basic timeline frame ranges
+- Source media frame ranges
+- Retimed clip frame ranges
 """
-Requires:
-    otioTimeline -> context data attribute
-    review -> instance data attribute
-    masterLayer -> instance data attribute
-    otioClipRange -> instance data attribute
-"""
+
 from pprint import pformat
 
+import opentimelineio as otio
 import pyblish.api
+from ayon_core.pipeline.editorial import (
+    get_media_range_with_retimes,
+    otio_range_to_frame_range,
+    otio_range_with_handles,
+)
 
 
-class CollectOtioFrameRanges(pyblish.api.InstancePlugin):
-    """Getting otio ranges from otio_clip
+def validate_otio_clip(instance, logger):
+    """Validate if instance has required OTIO clip data.
 
-    Adding timeline and source ranges to instance data"""
+    Args:
+        instance: The instance to validate
+        logger: Logger object to use for debug messages
 
-    label = "Collect OTIO Frame Ranges"
+    Returns:
+        bool: True if valid, False otherwise
+    """
+    if not instance.data.get("otioClip"):
+        logger.debug("Skipping collect OTIO range - no clip found.")
+        return False
+    return True
+
+
+class CollectOtioRanges(pyblish.api.InstancePlugin):
+    """Collect all OTIO-related frame ranges and timing information.
+
+    This plugin handles collection of:
+    - Basic timeline frame ranges with handles
+    - Source media frame ranges with handles
+    - Retimed clip frame ranges
+
+    Requires:
+        otioClip (otio.schema.Clip): OTIO clip object
+        workfileFrameStart (int): Starting frame of work file
+
+    Optional:
+        shotDurationFromSource (int): Duration from source if retimed
+
+    Provides:
+        frameStart (int): Start frame in timeline
+        frameEnd (int): End frame in timeline
+        clipIn (int): Clip in point
+        clipOut (int): Clip out point
+        clipInH (int): Clip in point with handles
+        clipOutH (int): Clip out point with handles
+        sourceStart (int): Source media start frame
+        sourceEnd (int): Source media end frame
+        sourceStartH (int): Source media start frame with handles
+        sourceEndH (int): Source media end frame with handles
+    """
+
+    label = "Collect OTIO Ranges"
     order = pyblish.api.CollectorOrder - 0.08
     families = ["shot", "clip"]
-    hosts = ["resolve", "hiero", "flame", "traypublisher"]
 
     def process(self, instance):
-        # Not all hosts can import these modules.
-        import opentimelineio as otio
-        from ayon_core.pipeline.editorial import (
-            get_media_range_with_retimes,
-            otio_range_to_frame_range,
-            otio_range_with_handles
-        )
+        """Process the instance to collect all frame ranges.
 
-        if not instance.data.get("otioClip"):
-            self.log.debug("Skipping collect OTIO frame range.")
+        Args:
+            instance: The instance to process
+        """
+        if not validate_otio_clip(instance, self.log):
             return
 
-        # get basic variables
         otio_clip = instance.data["otioClip"]
+
+        # Collect timeline ranges if workfile start frame is available
+        if "workfileFrameStart" in instance.data:
+            self._collect_timeline_ranges(instance, otio_clip)
+
+        # Traypublisher Simple or Advanced editorial publishing is
+        # working with otio clips which are having no available range
+        # because they are not having any media references.
+        try:
+            otio_clip.available_range()
+            has_available_range = True
+        except otio._otio.CannotComputeAvailableRangeError:
+            self.log.info("Clip has no available range")
+            has_available_range = False
+
+        # Collect source ranges if clip has available range
+        if has_available_range:
+            self._collect_source_ranges(instance, otio_clip)
+
+        # Handle retimed ranges if source duration is available
+        if "shotDurationFromSource" in instance.data:
+            self._collect_retimed_ranges(instance, otio_clip)
+
+    def _collect_timeline_ranges(self, instance, otio_clip):
+        """Collect basic timeline frame ranges."""
         workfile_start = instance.data["workfileFrameStart"]
-        workfile_source_duration = instance.data.get("shotDurationFromSource")
 
-        # get ranges
+        # Get timeline ranges
         otio_tl_range = otio_clip.range_in_parent()
-        otio_src_range = otio_clip.source_range
-        otio_avalable_range = otio_clip.available_range()
         otio_tl_range_handles = otio_range_with_handles(
-            otio_tl_range, instance)
-        otio_src_range_handles = otio_range_with_handles(
-            otio_src_range, instance)
+            otio_tl_range,
+            instance
+        )
 
-        # get source avalable start frame
-        src_starting_from = otio.opentime.to_frames(
-            otio_avalable_range.start_time,
-            otio_avalable_range.start_time.rate)
+        # Convert to frames
+        tl_start, tl_end = otio_range_to_frame_range(otio_tl_range)
+        tl_start_h, tl_end_h = otio_range_to_frame_range(otio_tl_range_handles)
 
-        # convert to frames
-        range_convert = otio_range_to_frame_range
-        tl_start, tl_end = range_convert(otio_tl_range)
-        tl_start_h, tl_end_h = range_convert(otio_tl_range_handles)
-        src_start, src_end = range_convert(otio_src_range)
-        src_start_h, src_end_h = range_convert(otio_src_range_handles)
         frame_start = workfile_start
-        frame_end = frame_start + otio.opentime.to_frames(
-            otio_tl_range.duration, otio_tl_range.duration.rate) - 1
-
-        # in case of retimed clip and frame range should not be retimed
-        if workfile_source_duration:
-            # get available range trimmed with processed retimes
-            retimed_attributes = get_media_range_with_retimes(
-                otio_clip, 0, 0)
-            self.log.debug(
-                ">> retimed_attributes: {}".format(retimed_attributes))
-            media_in = int(retimed_attributes["mediaIn"])
-            media_out = int(retimed_attributes["mediaOut"])
-            frame_end = frame_start + (media_out - media_in) + 1
-            self.log.debug(frame_end)
+        frame_end = frame_start + otio_tl_range.duration.to_frames() - 1
 
         data = {
             "frameStart": frame_start,
@@ -81,13 +123,77 @@ class CollectOtioFrameRanges(pyblish.api.InstancePlugin):
             "clipOut": tl_end - 1,
             "clipInH": tl_start_h,
             "clipOutH": tl_end_h - 1,
-            "sourceStart": src_starting_from + src_start,
-            "sourceEnd": src_starting_from + src_end - 1,
-            "sourceStartH": src_starting_from + src_start_h,
-            "sourceEndH": src_starting_from + src_end_h - 1,
         }
         instance.data.update(data)
-        self.log.debug(
-            "_ data: {}".format(pformat(data)))
-        self.log.debug(
-            "_ instance.data: {}".format(pformat(instance.data)))
+        self.log.debug(f"Added frame ranges: {pformat(data)}")
+
+    def _collect_source_ranges(self, instance, otio_clip):
+        """Collect source media frame ranges."""
+        # Get source ranges
+        otio_src_range = otio_clip.source_range
+        otio_available_range = otio_clip.available_range()
+
+        # Backward-compatibility for Hiero OTIO exporter.
+        # NTSC compatibility might introduce floating rates, when these are
+        # not exactly the same (23.976 vs 23.976024627685547)
+        # this will cause precision issue in computation.
+        # Currently round to 2 decimals for comparison,
+        # but this should always rescale after that.
+        rounded_av_rate = round(otio_available_range.start_time.rate, 2)
+        rounded_src_rate = round(otio_src_range.start_time.rate, 2)
+        if rounded_av_rate != rounded_src_rate:
+            conformed_src_in = otio_src_range.start_time.rescaled_to(
+                otio_available_range.start_time.rate
+            )
+            conformed_src_duration = otio_src_range.duration.rescaled_to(
+                otio_available_range.duration.rate
+            )
+            conformed_source_range = otio.opentime.TimeRange(
+                start_time=conformed_src_in,
+                duration=conformed_src_duration
+            )
+        else:
+            conformed_source_range = otio_src_range
+
+        source_start = conformed_source_range.start_time
+        source_end = source_start + conformed_source_range.duration
+        handle_start = otio.opentime.RationalTime(
+            instance.data.get("handleStart", 0),
+            source_start.rate
+        )
+        handle_end = otio.opentime.RationalTime(
+            instance.data.get("handleEnd", 0),
+            source_start.rate
+        )
+        source_start_h = source_start - handle_start
+        source_end_h = source_end + handle_end
+        data = {
+            "sourceStart": source_start.to_frames(),
+            "sourceEnd": source_end.to_frames() - 1,
+            "sourceStartH": source_start_h.to_frames(),
+            "sourceEndH": source_end_h.to_frames() - 1,
+        }
+        instance.data.update(data)
+        self.log.debug(f"Added source ranges: {pformat(data)}")
+
+    def _collect_retimed_ranges(self, instance, otio_clip):
+        """Handle retimed clip frame ranges."""
+        retimed_attributes = get_media_range_with_retimes(otio_clip, 0, 0)
+        self.log.debug(f"Retimed attributes: {retimed_attributes}")
+
+        frame_start = instance.data["frameStart"]
+        media_in = int(retimed_attributes["mediaIn"])
+        media_out = int(retimed_attributes["mediaOut"])
+        frame_end = frame_start + (media_out - media_in)
+
+        data = {
+            "frameStart": frame_start,
+            "frameEnd": frame_end,
+            "sourceStart": media_in,
+            "sourceEnd": media_out,
+            "sourceStartH": media_in - int(retimed_attributes["handleStart"]),
+            "sourceEndH": media_out + int(retimed_attributes["handleEnd"]),
+        }
+
+        instance.data.update(data)
+        self.log.debug(f"Updated retimed values: {data}")

client/ayon_core/plugins/publish/extract_otio_review.py

@@ -286,7 +286,7 @@ class ExtractOTIOReview(
             )
 
         instance.data["representations"].append(representation)
-        self.log.info("Adding representation: {}".format(representation))
+        self.log.debug("Adding representation: {}".format(representation))
 
     def _create_representation(self, start, duration):
         """

client/ayon_core/plugins/publish/extract_thumbnail.py

@@ -343,8 +343,7 @@ class ExtractThumbnail(pyblish.api.InstancePlugin):
                 # to be published locally
                 continue
 
-            valid = "review" in tags or "thumb-nuke" in tags
-            if not valid:
+            if "review" not in tags:
                 continue
 
             if not repre.get("files"):

client/ayon_core/plugins/publish/extract_usd_layer_contributions.py

@@ -1,7 +1,7 @@
 from operator import attrgetter
 import dataclasses
 import os
-from typing import Dict
+from typing import Any, Dict, List
 
 import pyblish.api
 try:
@@ -14,7 +14,8 @@ from ayon_core.lib import (
     BoolDef,
     UISeparatorDef,
     UILabelDef,
-    EnumDef
+    EnumDef,
+    filter_profiles
 )
 try:
     from ayon_core.pipeline.usdlib import (
@@ -281,6 +282,9 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
         "fx": 500,
         "lighting": 600,
     }
+    # Default profiles to set certain instance attribute defaults based on
+    # profiles in settings
+    profiles: List[Dict[str, Any]] = []
 
     @classmethod
     def apply_settings(cls, project_settings):
@@ -298,6 +302,8 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
         if contribution_layers:
             cls.contribution_layers = contribution_layers
 
+        cls.profiles = plugin_settings.get("profiles", [])
+
     def process(self, instance):
 
         attr_values = self.get_attr_values_from_data(instance.data)
@@ -463,6 +469,29 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
         if not cls.instance_matches_plugin_families(instance):
             return []
 
+        # Set default target layer based on product type
+        current_context_task_type = create_context.get_current_task_type()
+        profile = filter_profiles(cls.profiles, {
+            "product_types": instance.data["productType"],
+            "task_types": current_context_task_type
+        })
+        if not profile:
+            profile = {}
+
+        # Define defaults
+        default_enabled = profile.get("contribution_enabled", True)
+        default_contribution_layer = profile.get(
+            "contribution_layer", None)
+        default_apply_as_variant = profile.get(
+            "contribution_apply_as_variant", False)
+        default_target_product = profile.get(
+            "contribution_target_product", "usdAsset")
+        default_init_as = (
+            "asset"
+            if profile.get("contribution_target_product") == "usdAsset"
+            else "shot")
+        init_as_visible = False
+
         # Attributes logic
         publish_attributes = instance["publish_attributes"].get(
             cls.__name__, {})
@@ -485,7 +514,7 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
                         "In both cases the USD data itself is free to have "
                         "references and sublayers of its own."
                     ),
-                    default=True),
+                    default=default_enabled),
             TextDef("contribution_target_product",
                     label="Target product",
                     tooltip=(
@@ -495,7 +524,7 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
                         "the contribution itself will be added to the "
                         "department layer."
                     ),
-                    default="usdAsset",
+                    default=default_target_product,
                     visible=visible),
             EnumDef("contribution_target_product_init",
                     label="Initialize as",
@@ -507,8 +536,8 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
                         "setting will do nothing."
                     ),
                     items=["asset", "shot"],
-                    default="asset",
-                    visible=visible),
+                    default=default_init_as,
+                    visible=visible and init_as_visible),
 
             # Asset layer, e.g. model.usd, look.usd, rig.usd
             EnumDef("contribution_layer",
@@ -520,7 +549,7 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
                         "the list) will contribute as a stronger opinion."
                     ),
                     items=list(cls.contribution_layers.keys()),
-                    default="model",
+                    default=default_contribution_layer,
                     visible=visible),
             BoolDef("contribution_apply_as_variant",
                     label="Add as variant",
@@ -532,7 +561,7 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
                         "appended to as a sublayer to the department layer "
                         "instead."
                     ),
-                    default=True,
+                    default=default_apply_as_variant,
                     visible=visible),
             TextDef("contribution_variant_set_name",
                     label="Variant Set Name",
@@ -588,31 +617,6 @@ class CollectUSDLayerContributions(pyblish.api.InstancePlugin,
             instance.set_publish_plugin_attr_defs(cls.__name__, new_attrs)
 
 
-class CollectUSDLayerContributionsHoudiniLook(CollectUSDLayerContributions):
-    """
-    This is solely here to expose the attribute definitions for the
-    Houdini "look" family.
-    """
-    # TODO: Improve how this is built for the look family
-    hosts = ["houdini"]
-    families = ["look"]
-    label = CollectUSDLayerContributions.label + " (Look)"
-
-    @classmethod
-    def get_attr_defs_for_instance(cls, create_context, instance):
-        # Filtering of instance, if needed, can be customized
-        if not cls.instance_matches_plugin_families(instance):
-            return []
-
-        defs = super().get_attr_defs_for_instance(create_context, instance)
-
-        # Update default for department layer to look
-        layer_def = next(d for d in defs if d.key == "contribution_layer")
-        layer_def.default = "look"
-
-        return defs
-
-
 class ValidateUSDDependencies(pyblish.api.InstancePlugin):
     families = ["usdLayer"]
 

client/ayon_core/tools/loader/abstract.py

@@ -108,6 +108,7 @@ class VersionItem:
         version (int): Version. Can be negative when is hero version.
         is_hero (bool): Is hero version.
         product_id (str): Product id.
+        task_id (Union[str, None]): Task id.
         thumbnail_id (Union[str, None]): Thumbnail id.
         published_time (Union[str, None]): Published time in format
             '%Y%m%dT%H%M%SZ'.
@@ -127,6 +128,7 @@ class VersionItem:
         version,
         is_hero,
         product_id,
+        task_id,
         thumbnail_id,
         published_time,
         author,
@@ -140,6 +142,7 @@ class VersionItem:
     ):
         self.version_id = version_id
         self.product_id = product_id
+        self.task_id = task_id
         self.thumbnail_id = thumbnail_id
         self.version = version
         self.is_hero = is_hero
@@ -161,6 +164,7 @@ class VersionItem:
             and self.version == other.version
             and self.version_id == other.version_id
             and self.product_id == other.product_id
+            and self.task_id == other.task_id
         )
 
     def __ne__(self, other):
@@ -198,6 +202,7 @@ class VersionItem:
         return {
             "version_id": self.version_id,
             "product_id": self.product_id,
+            "task_id": self.task_id,
             "thumbnail_id": self.thumbnail_id,
             "version": self.version,
             "is_hero": self.is_hero,
@@ -536,6 +541,55 @@ class FrontendLoaderController(_BaseLoaderController):
         """
         pass
 
+    @abstractmethod
+    def get_task_items(self, project_name, folder_ids, sender=None):
+        """Task items for folder ids.
+
+        Args:
+            project_name (str): Project name.
+            folder_ids (Iterable[str]): Folder ids.
+            sender (Optional[str]): Sender who requested the items.
+
+        Returns:
+            list[TaskItem]: List of task items.
+
+        """
+        pass
+
+    @abstractmethod
+    def get_task_type_items(self, project_name, sender=None):
+        """Task type items for a project.
+
+        This function may trigger events with topics
+        'projects.task_types.refresh.started' and
+        'projects.task_types.refresh.finished' which will contain 'sender'
+        value in data.
+        That may help to avoid re-refresh of items in UI elements.
+
+        Args:
+            project_name (str): Project name.
+            sender (str): Who requested task type items.
+
+        Returns:
+            list[TaskTypeItem]: Task type information.
+
+        """
+        pass
+
+    @abstractmethod
+    def get_folder_labels(self, project_name, folder_ids):
+        """Get folder labels for folder ids.
+
+        Args:
+            project_name (str): Project name.
+            folder_ids (Iterable[str]): Folder ids.
+
+        Returns:
+            dict[str, Optional[str]]: Folder labels by folder id.
+
+        """
+        pass
+
     @abstractmethod
     def get_project_status_items(self, project_name, sender=None):
         """Items for all projects available on server.
@@ -717,8 +771,30 @@ class FrontendLoaderController(_BaseLoaderController):
 
         Returns:
             list[str]: Selected folder ids.
-        """
 
+        """
+        pass
+
+    @abstractmethod
+    def get_selected_task_ids(self):
+        """Get selected task ids.
+
+        The information is based on last selection from UI.
+
+        Returns:
+            list[str]: Selected folder ids.
+
+        """
+        pass
+
+    @abstractmethod
+    def set_selected_tasks(self, task_ids):
+        """Set selected tasks.
+
+        Args:
+            task_ids (Iterable[str]): Selected task ids.
+
+        """
         pass
 
     @abstractmethod
@@ -729,8 +805,8 @@ class FrontendLoaderController(_BaseLoaderController):
 
         Returns:
             list[str]: Selected version ids.
-        """
 
+        """
         pass
 
     @abstractmethod

client/ayon_core/tools/loader/control.py

@@ -198,6 +198,31 @@ class LoaderController(BackendLoaderController, FrontendLoaderController):
     def get_folder_items(self, project_name, sender=None):
         return self._hierarchy_model.get_folder_items(project_name, sender)
 
+    def get_task_items(self, project_name, folder_ids, sender=None):
+        output = []
+        for folder_id in folder_ids:
+            output.extend(self._hierarchy_model.get_task_items(
+                project_name, folder_id, sender
+            ))
+        return output
+
+    def get_task_type_items(self, project_name, sender=None):
+        return self._projects_model.get_task_type_items(
+            project_name, sender
+        )
+
+    def get_folder_labels(self, project_name, folder_ids):
+        folder_items_by_id = self._hierarchy_model.get_folder_items_by_id(
+            project_name, folder_ids
+        )
+        output = {}
+        for folder_id, folder_item in folder_items_by_id.items():
+            label = None
+            if folder_item is not None:
+                label = folder_item.label
+            output[folder_id] = label
+        return output
+
     def get_product_items(self, project_name, folder_ids, sender=None):
         return self._products_model.get_product_items(
             project_name, folder_ids, sender)
@@ -299,6 +324,12 @@ class LoaderController(BackendLoaderController, FrontendLoaderController):
     def set_selected_folders(self, folder_ids):
         self._selection_model.set_selected_folders(folder_ids)
 
+    def get_selected_task_ids(self):
+        return self._selection_model.get_selected_task_ids()
+
+    def set_selected_tasks(self, task_ids):
+        self._selection_model.set_selected_tasks(task_ids)
+
     def get_selected_version_ids(self):
         return self._selection_model.get_selected_version_ids()
 

client/ayon_core/tools/loader/models/products.py

@@ -55,6 +55,7 @@ def version_item_from_entity(version):
         version=version_num,
         is_hero=is_hero,
         product_id=version["productId"],
+        task_id=version["taskId"],
         thumbnail_id=version["thumbnailId"],
         published_time=published_time,
         author=author,

client/ayon_core/tools/loader/models/selection.py

@@ -14,6 +14,7 @@ class SelectionModel(object):
 
         self._project_name = None
         self._folder_ids = set()
+        self._task_ids = set()
         self._version_ids = set()
         self._representation_ids = set()
 
@@ -48,6 +49,23 @@ class SelectionModel(object):
             self.event_source
         )
 
+    def get_selected_task_ids(self):
+        return self._task_ids
+
+    def set_selected_tasks(self, task_ids):
+        if task_ids == self._task_ids:
+            return
+
+        self._task_ids = task_ids
+        self._controller.emit_event(
+            "selection.tasks.changed",
+            {
+                "project_name": self._project_name,
+                "task_ids": task_ids,
+            },
+            self.event_source
+        )
+
     def get_selected_version_ids(self):
         return self._version_ids
 

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

@@ -1,7 +1,10 @@
+from __future__ import annotations
+import typing
 from typing import List, Tuple, Optional, Iterable, Any
 
 from qtpy import QtWidgets, QtCore, QtGui
 
+from ayon_core.tools.utils import get_qt_icon
 from ayon_core.tools.utils.lib import (
     checkstate_int_to_enum,
     checkstate_enum_to_int,
@@ -11,14 +14,269 @@ from ayon_core.tools.utils.constants import (
     UNCHECKED_INT,
     ITEM_IS_USER_TRISTATE,
 )
+if typing.TYPE_CHECKING:
+    from ayon_core.tools.loader.abstract import FrontendLoaderController
 
 VALUE_ITEM_TYPE = 0
 STANDARD_ITEM_TYPE = 1
 SEPARATOR_ITEM_TYPE = 2
 
+VALUE_ITEM_SUBTYPE = 0
+SELECT_ALL_SUBTYPE = 1
+DESELECT_ALL_SUBTYPE = 2
+SWAP_STATE_SUBTYPE = 3
+
+
+class BaseQtModel(QtGui.QStandardItemModel):
+    _empty_icon = None
+
+    def __init__(
+        self,
+        item_type_role: int,
+        item_subtype_role: int,
+        empty_values_label: str,
+        controller: FrontendLoaderController,
+    ):
+        self._item_type_role = item_type_role
+        self._item_subtype_role = item_subtype_role
+        self._empty_values_label = empty_values_label
+        self._controller = controller
+
+        self._last_project = None
+
+        self._select_project_item = None
+        self._empty_values_item = None
+
+        self._select_all_item = None
+        self._deselect_all_item = None
+        self._swap_states_item = None
+
+        super().__init__()
+
+        self.refresh(None)
+
+    def _get_standard_items(self) -> list[QtGui.QStandardItem]:
+        raise NotImplementedError(
+            "'_get_standard_items' is not implemented"
+            f" for {self.__class__}"
+        )
+
+    def _clear_standard_items(self):
+        raise NotImplementedError(
+            "'_clear_standard_items' is not implemented"
+            f" for {self.__class__}"
+        )
+
+    def _prepare_new_value_items(
+        self, project_name: str, project_changed: bool
+    ) -> tuple[
+        list[QtGui.QStandardItem], list[QtGui.QStandardItem]
+    ]:
+        raise NotImplementedError(
+            "'_prepare_new_value_items' is not implemented"
+            f" for {self.__class__}"
+        )
+
+    def refresh(self, project_name: Optional[str]):
+        # New project was selected
+        project_changed = False
+        if project_name != self._last_project:
+            self._last_project = project_name
+            project_changed = True
+
+        if project_name is None:
+            self._add_select_project_item()
+            return
+
+        value_items, items_to_remove = self._prepare_new_value_items(
+            project_name, project_changed
+        )
+        if not value_items:
+            self._add_empty_values_item()
+            return
+
+        self._remove_empty_items()
+
+        root_item = self.invisibleRootItem()
+        for row_idx, value_item in enumerate(value_items):
+            if value_item.row() == row_idx:
+                continue
+            if value_item.row() >= 0:
+                root_item.takeRow(value_item.row())
+            root_item.insertRow(row_idx, value_item)
+
+        for item in items_to_remove:
+            root_item.removeRow(item.row())
+
+        self._add_selection_items()
+
+    def setData(self, index, value, role):
+        if role == QtCore.Qt.CheckStateRole and index.isValid():
+            item_subtype = index.data(self._item_subtype_role)
+            if item_subtype == SELECT_ALL_SUBTYPE:
+                for item in self._get_standard_items():
+                    item.setCheckState(QtCore.Qt.Checked)
+                return True
+            if item_subtype == DESELECT_ALL_SUBTYPE:
+                for item in self._get_standard_items():
+                    item.setCheckState(QtCore.Qt.Unchecked)
+                return True
+            if item_subtype == SWAP_STATE_SUBTYPE:
+                for item in self._get_standard_items():
+                    current_state = item.checkState()
+                    item.setCheckState(
+                        QtCore.Qt.Checked
+                        if current_state == QtCore.Qt.Unchecked
+                        else QtCore.Qt.Unchecked
+                    )
+                return True
+        return super().setData(index, value, role)
+
+    @classmethod
+    def _get_empty_icon(cls):
+        if cls._empty_icon is None:
+            pix = QtGui.QPixmap(1, 1)
+            pix.fill(QtCore.Qt.transparent)
+            cls._empty_icon = QtGui.QIcon(pix)
+        return cls._empty_icon
+
+    def _init_default_items(self):
+        if self._empty_values_item is not None:
+            return
+
+        empty_values_item = QtGui.QStandardItem(self._empty_values_label)
+        select_project_item = QtGui.QStandardItem("Select project...")
+
+        select_all_item = QtGui.QStandardItem("Select all")
+        deselect_all_item = QtGui.QStandardItem("Deselect all")
+        swap_states_item = QtGui.QStandardItem("Swap")
+
+        for item in (
+            empty_values_item,
+            select_project_item,
+            select_all_item,
+            deselect_all_item,
+            swap_states_item,
+        ):
+            item.setData(STANDARD_ITEM_TYPE, self._item_type_role)
+
+        select_all_item.setIcon(get_qt_icon({
+            "type": "material-symbols",
+            "name": "done_all",
+            "color": "white"
+        }))
+        deselect_all_item.setIcon(get_qt_icon({
+            "type": "material-symbols",
+            "name": "remove_done",
+            "color": "white"
+        }))
+        swap_states_item.setIcon(get_qt_icon({
+            "type": "material-symbols",
+            "name": "swap_horiz",
+            "color": "white"
+        }))
+
+        for item in (
+            empty_values_item,
+            select_project_item,
+        ):
+            item.setFlags(QtCore.Qt.NoItemFlags)
+
+        for item, item_type in (
+            (select_all_item, SELECT_ALL_SUBTYPE),
+            (deselect_all_item, DESELECT_ALL_SUBTYPE),
+            (swap_states_item, SWAP_STATE_SUBTYPE),
+        ):
+            item.setData(item_type, self._item_subtype_role)
+
+        for item in (
+            select_all_item,
+            deselect_all_item,
+            swap_states_item,
+        ):
+            item.setFlags(
+                QtCore.Qt.ItemIsEnabled
+                | QtCore.Qt.ItemIsSelectable
+                | QtCore.Qt.ItemIsUserCheckable
+            )
+
+        self._empty_values_item = empty_values_item
+        self._select_project_item = select_project_item
+
+        self._select_all_item = select_all_item
+        self._deselect_all_item = deselect_all_item
+        self._swap_states_item = swap_states_item
+
+    def _get_empty_values_item(self):
+        self._init_default_items()
+        return self._empty_values_item
+
+    def _get_select_project_item(self):
+        self._init_default_items()
+        return self._select_project_item
+
+    def _get_empty_items(self):
+        self._init_default_items()
+        return [
+            self._empty_values_item,
+            self._select_project_item,
+        ]
+
+    def _get_selection_items(self):
+        self._init_default_items()
+        return [
+            self._select_all_item,
+            self._deselect_all_item,
+            self._swap_states_item,
+        ]
+
+    def _get_default_items(self):
+        return self._get_empty_items() + self._get_selection_items()
+
+    def _add_select_project_item(self):
+        item = self._get_select_project_item()
+        if item.row() < 0:
+            self._remove_items()
+            root_item = self.invisibleRootItem()
+            root_item.appendRow(item)
+
+    def _add_empty_values_item(self):
+        item = self._get_empty_values_item()
+        if item.row() < 0:
+            self._remove_items()
+            root_item = self.invisibleRootItem()
+            root_item.appendRow(item)
+
+    def _add_selection_items(self):
+        root_item = self.invisibleRootItem()
+        items = self._get_selection_items()
+        for item in self._get_selection_items():
+            row = item.row()
+            if row >= 0:
+                root_item.takeRow(row)
+        root_item.appendRows(items)
+
+    def _remove_items(self):
+        root_item = self.invisibleRootItem()
+        for item in self._get_default_items():
+            if item.row() < 0:
+                continue
+            root_item.takeRow(item.row())
+
+        root_item.removeRows(0, root_item.rowCount())
+        self._clear_standard_items()
+
+    def _remove_empty_items(self):
+        root_item = self.invisibleRootItem()
+        for item in self._get_empty_items():
+            if item.row() < 0:
+                continue
+            root_item.takeRow(item.row())
+
 
 class CustomPaintDelegate(QtWidgets.QStyledItemDelegate):
     """Delegate showing status name and short name."""
+    _empty_icon = None
     _checked_value = checkstate_enum_to_int(QtCore.Qt.Checked)
     _checked_bg_color = QtGui.QColor("#2C3B4C")
 
@@ -38,6 +296,14 @@ class CustomPaintDelegate(QtWidgets.QStyledItemDelegate):
         self._icon_role = icon_role
         self._item_type_role = item_type_role
 
+    @classmethod
+    def _get_empty_icon(cls):
+        if cls._empty_icon is None:
+            pix = QtGui.QPixmap(1, 1)
+            pix.fill(QtCore.Qt.transparent)
+            cls._empty_icon = QtGui.QIcon(pix)
+        return cls._empty_icon
+
     def paint(self, painter, option, index):
         item_type = None
         if self._item_type_role is not None:
@@ -70,6 +336,9 @@ class CustomPaintDelegate(QtWidgets.QStyledItemDelegate):
         if option.state & QtWidgets.QStyle.State_Open:
             state = QtGui.QIcon.On
         icon = self._get_index_icon(index)
+        if icon is None or icon.isNull():
+            icon = self._get_empty_icon()
+
         option.features |= QtWidgets.QStyleOptionViewItem.HasDecoration
 
         # Disable visible check indicator
@@ -241,6 +510,10 @@ class CustomPaintMultiselectComboBox(QtWidgets.QComboBox):
         QtCore.Qt.Key_Home,
         QtCore.Qt.Key_End,
     }
+    _top_bottom_margins = 1
+    _top_bottom_padding = 2
+    _left_right_padding = 3
+    _item_bg_color = QtGui.QColor("#31424e")
 
     def __init__(
         self,
@@ -433,14 +706,14 @@ class CustomPaintMultiselectComboBox(QtWidgets.QComboBox):
 
         idxs = self._get_checked_idx()
         # draw the icon and text
-        draw_text = True
+        draw_items = False
         combotext = None
         if self._custom_text is not None:
             combotext = self._custom_text
         elif not idxs:
             combotext = self._placeholder_text
         else:
-            draw_text = False
+            draw_items = True
 
         content_field_rect = self.style().subControlRect(
             QtWidgets.QStyle.CC_ComboBox,
@@ -448,7 +721,9 @@ class CustomPaintMultiselectComboBox(QtWidgets.QComboBox):
             QtWidgets.QStyle.SC_ComboBoxEditField
         ).adjusted(1, 0, -1, 0)
 
-        if draw_text:
+        if draw_items:
+            self._paint_items(painter, idxs, content_field_rect)
+        else:
             color = option.palette.color(QtGui.QPalette.Text)
             color.setAlpha(67)
             pen = painter.pen()
@@ -459,15 +734,12 @@ class CustomPaintMultiselectComboBox(QtWidgets.QComboBox):
                 QtCore.Qt.AlignLeft | QtCore.Qt.AlignVCenter,
                 combotext
             )
-        else:
-            self._paint_items(painter, idxs, content_field_rect)
 
         painter.end()
 
     def _paint_items(self, painter, indexes, content_rect):
         origin_rect = QtCore.QRect(content_rect)
 
-        metrics = self.fontMetrics()
         model = self.model()
         available_width = content_rect.width()
         total_used_width = 0
@@ -482,31 +754,80 @@ class CustomPaintMultiselectComboBox(QtWidgets.QComboBox):
                 continue
 
             icon = index.data(self._icon_role)
-            # TODO handle this case
-            if icon is None or icon.isNull():
-                continue
+            text = index.data(self._text_role)
+            valid_icon = icon is not None and not icon.isNull()
+            if valid_icon:
+                sizes = icon.availableSizes()
+                if sizes:
+                    valid_icon = any(size.width() > 1 for size in sizes)
 
-            icon_rect = QtCore.QRect(content_rect)
-            diff = icon_rect.height() - metrics.height()
-            if diff < 0:
-                diff = 0
-            top_offset = diff // 2
-            bottom_offset = diff - top_offset
-            icon_rect.adjust(0, top_offset, 0, -bottom_offset)
-            icon_rect.setWidth(metrics.height())
-            icon.paint(
-                painter,
-                icon_rect,
-                QtCore.Qt.AlignCenter,
-                QtGui.QIcon.Normal,
-                QtGui.QIcon.On
-            )
-            content_rect.setLeft(icon_rect.right() + spacing)
-            if total_used_width > 0:
-                total_used_width += spacing
-            total_used_width += icon_rect.width()
-            if total_used_width > available_width:
-                break
+            if valid_icon:
+                metrics = self.fontMetrics()
+                icon_rect = QtCore.QRect(content_rect)
+                diff = icon_rect.height() - metrics.height()
+                if diff < 0:
+                    diff = 0
+                top_offset = diff // 2
+                bottom_offset = diff - top_offset
+                icon_rect.adjust(0, top_offset, 0, -bottom_offset)
+                used_width = metrics.height()
+                if total_used_width > 0:
+                    total_used_width += spacing
+                total_used_width += used_width
+                if total_used_width > available_width:
+                    break
+
+                icon_rect.setWidth(used_width)
+                icon.paint(
+                    painter,
+                    icon_rect,
+                    QtCore.Qt.AlignCenter,
+                    QtGui.QIcon.Normal,
+                    QtGui.QIcon.On
+                )
+                content_rect.setLeft(icon_rect.right() + spacing)
+
+            elif text:
+                bg_height = (
+                    content_rect.height()
+                    - (2 * self._top_bottom_margins)
+                )
+                font_height = bg_height - (2 * self._top_bottom_padding)
+
+                bg_top_y = content_rect.y() + self._top_bottom_margins
+
+                font = self.font()
+                font.setPixelSize(font_height)
+                metrics = QtGui.QFontMetrics(font)
+                painter.setFont(font)
+
+                label_rect = metrics.boundingRect(text)
+
+                bg_width = label_rect.width() + (2 * self._left_right_padding)
+                if total_used_width > 0:
+                    total_used_width += spacing
+                total_used_width += bg_width
+                if total_used_width > available_width:
+                    break
+
+                bg_rect = QtCore.QRectF(label_rect)
+                bg_rect.moveTop(bg_top_y)
+                bg_rect.moveLeft(content_rect.left())
+                bg_rect.setWidth(bg_width)
+                bg_rect.setHeight(bg_height)
+
+                label_rect.moveTop(bg_top_y)
+                label_rect.moveLeft(
+                    content_rect.left() + self._left_right_padding
+                )
+
+                path = QtGui.QPainterPath()
+                path.addRoundedRect(bg_rect, 5, 5)
+
+                painter.fillPath(path, self._item_bg_color)
+                painter.drawText(label_rect, QtCore.Qt.AlignCenter, text)
+
+                content_rect.setLeft(bg_rect.right() + spacing)
 
         painter.restore()
 

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

@@ -0,0 +1,169 @@
+from qtpy import QtGui, QtCore
+
+from ._multicombobox import (
+    CustomPaintMultiselectComboBox,
+    BaseQtModel,
+)
+
+STATUS_ITEM_TYPE = 0
+SELECT_ALL_TYPE = 1
+DESELECT_ALL_TYPE = 2
+SWAP_STATE_TYPE = 3
+
+PRODUCT_TYPE_ROLE = QtCore.Qt.UserRole + 1
+ITEM_TYPE_ROLE = QtCore.Qt.UserRole + 2
+ITEM_SUBTYPE_ROLE = QtCore.Qt.UserRole + 3
+
+
+class ProductTypesQtModel(BaseQtModel):
+    refreshed = QtCore.Signal()
+
+    def __init__(self, controller):
+        self._reset_filters_on_refresh = True
+        self._refreshing = False
+        self._bulk_change = False
+        self._items_by_name = {}
+
+        super().__init__(
+            item_type_role=ITEM_TYPE_ROLE,
+            item_subtype_role=ITEM_SUBTYPE_ROLE,
+            empty_values_label="No product types...",
+            controller=controller,
+        )
+
+    def is_refreshing(self):
+        return self._refreshing
+
+    def refresh(self, project_name):
+        self._refreshing = True
+        super().refresh(project_name)
+
+        self._reset_filters_on_refresh = False
+        self._refreshing = False
+        self.refreshed.emit()
+
+    def reset_product_types_filter_on_refresh(self):
+        self._reset_filters_on_refresh = True
+
+    def _get_standard_items(self) -> list[QtGui.QStandardItem]:
+        return list(self._items_by_name.values())
+
+    def _clear_standard_items(self):
+        self._items_by_name.clear()
+
+    def _prepare_new_value_items(self, project_name: str, _: bool) -> tuple[
+        list[QtGui.QStandardItem], list[QtGui.QStandardItem]
+    ]:
+        product_type_items = self._controller.get_product_type_items(
+            project_name)
+        self._last_project = project_name
+
+        names_to_remove = set(self._items_by_name.keys())
+        items = []
+        items_filter_required = {}
+        for product_type_item in product_type_items:
+            name = product_type_item.name
+            names_to_remove.discard(name)
+            item = self._items_by_name.get(name)
+            # Apply filter to new items or if filters reset is requested
+            filter_required = self._reset_filters_on_refresh
+            if item is None:
+                filter_required = True
+                item = QtGui.QStandardItem(name)
+                item.setData(name, PRODUCT_TYPE_ROLE)
+                item.setEditable(False)
+                item.setCheckable(True)
+                self._items_by_name[name] = item
+
+            items.append(item)
+
+            if filter_required:
+                items_filter_required[name] = item
+
+        if items_filter_required:
+            product_types_filter = self._controller.get_product_types_filter()
+            for product_type, item in items_filter_required.items():
+                matching = (
+                    int(product_type in product_types_filter.product_types)
+                    + int(product_types_filter.is_allow_list)
+                )
+                item.setCheckState(
+                    QtCore.Qt.Checked
+                    if matching % 2 == 0
+                    else QtCore.Qt.Unchecked
+                )
+
+        items_to_remove = []
+        for name in names_to_remove:
+            items_to_remove.append(
+                self._items_by_name.pop(name)
+            )
+
+        # Uncheck all if all are checked (same result)
+        if all(
+            item.checkState() == QtCore.Qt.Checked
+            for item in items
+        ):
+            for item in items:
+                item.setCheckState(QtCore.Qt.Unchecked)
+
+        return items, items_to_remove
+
+
+class ProductTypesCombobox(CustomPaintMultiselectComboBox):
+    def __init__(self, controller, parent):
+        self._controller = controller
+        model = ProductTypesQtModel(controller)
+        super().__init__(
+            PRODUCT_TYPE_ROLE,
+            PRODUCT_TYPE_ROLE,
+            QtCore.Qt.ForegroundRole,
+            QtCore.Qt.DecorationRole,
+            item_type_role=ITEM_TYPE_ROLE,
+            model=model,
+            parent=parent
+        )
+
+        model.refreshed.connect(self._on_model_refresh)
+
+        self.set_placeholder_text("Product types filter...")
+        self._model = model
+        self._last_project_name = None
+        self._fully_disabled_filter = False
+
+        controller.register_event_callback(
+            "selection.project.changed",
+            self._on_project_change
+        )
+        controller.register_event_callback(
+            "projects.refresh.finished",
+            self._on_projects_refresh
+        )
+        self.setToolTip("Product types filter")
+        self.value_changed.connect(
+            self._on_product_type_filter_change
+        )
+
+    def reset_product_types_filter_on_refresh(self):
+        self._model.reset_product_types_filter_on_refresh()
+
+    def _on_model_refresh(self):
+        self.value_changed.emit()
+
+    def _on_product_type_filter_change(self):
+        lines = ["Product types filter"]
+        for item in self.get_value_info():
+            status_name, enabled = item
+            lines.append(f"{'✔' if enabled else '☐'} {status_name}")
+
+        self.setToolTip("\n".join(lines))
+
+    def _on_project_change(self, event):
+        project_name = event["project_name"]
+        self._last_project_name = project_name
+        self._model.refresh(project_name)
+
+    def _on_projects_refresh(self):
+        if self._last_project_name:
+            self._model.refresh(self._last_project_name)
+            self._on_product_type_filter_change()

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

@@ -1,256 +0,0 @@
-from qtpy import QtWidgets, QtGui, QtCore
-
-from ayon_core.tools.utils import get_qt_icon
-
-PRODUCT_TYPE_ROLE = QtCore.Qt.UserRole + 1
-
-
-class ProductTypesQtModel(QtGui.QStandardItemModel):
-    refreshed = QtCore.Signal()
-    filter_changed = QtCore.Signal()
-
-    def __init__(self, controller):
-        super(ProductTypesQtModel, self).__init__()
-        self._controller = controller
-
-        self._reset_filters_on_refresh = True
-        self._refreshing = False
-        self._bulk_change = False
-        self._last_project = None
-        self._items_by_name = {}
-
-        controller.register_event_callback(
-            "controller.reset.finished",
-            self._on_controller_reset_finish,
-        )
-
-    def is_refreshing(self):
-        return self._refreshing
-
-    def get_filter_info(self):
-        """Product types filtering info.
-
-        Returns:
-            dict[str, bool]: Filtering value by product type name. False value
-                means to hide product type.
-        """
-
-        return {
-            name: item.checkState() == QtCore.Qt.Checked
-            for name, item in self._items_by_name.items()
-        }
-
-    def refresh(self, project_name):
-        self._refreshing = True
-        product_type_items = self._controller.get_product_type_items(
-            project_name)
-        self._last_project = project_name
-
-        items_to_remove = set(self._items_by_name.keys())
-        new_items = []
-        items_filter_required = {}
-        for product_type_item in product_type_items:
-            name = product_type_item.name
-            items_to_remove.discard(name)
-            item = self._items_by_name.get(name)
-            # Apply filter to new items or if filters reset is requested
-            filter_required = self._reset_filters_on_refresh
-            if item is None:
-                filter_required = True
-                item = QtGui.QStandardItem(name)
-                item.setData(name, PRODUCT_TYPE_ROLE)
-                item.setEditable(False)
-                item.setCheckable(True)
-                new_items.append(item)
-                self._items_by_name[name] = item
-
-            if filter_required:
-                items_filter_required[name] = item
-
-            icon = get_qt_icon(product_type_item.icon)
-            item.setData(icon, QtCore.Qt.DecorationRole)
-
-        if items_filter_required:
-            product_types_filter = self._controller.get_product_types_filter()
-            for product_type, item in items_filter_required.items():
-                matching = (
-                    int(product_type in product_types_filter.product_types)
-                    + int(product_types_filter.is_allow_list)
-                )
-                state = (
-                    QtCore.Qt.Checked
-                    if matching % 2 == 0
-                    else QtCore.Qt.Unchecked
-                )
-                item.setCheckState(state)
-
-        root_item = self.invisibleRootItem()
-        if new_items:
-            root_item.appendRows(new_items)
-
-        for name in items_to_remove:
-            item = self._items_by_name.pop(name)
-            root_item.removeRow(item.row())
-
-        self._reset_filters_on_refresh = False
-        self._refreshing = False
-        self.refreshed.emit()
-
-    def reset_product_types_filter_on_refresh(self):
-        self._reset_filters_on_refresh = True
-
-    def setData(self, index, value, role=None):
-        checkstate_changed = False
-        if role is None:
-            role = QtCore.Qt.EditRole
-        elif role == QtCore.Qt.CheckStateRole:
-            checkstate_changed = True
-        output = super(ProductTypesQtModel, self).setData(index, value, role)
-        if checkstate_changed and not self._bulk_change:
-            self.filter_changed.emit()
-        return output
-
-    def change_state_for_all(self, checked):
-        if self._items_by_name:
-            self.change_states(checked, self._items_by_name.keys())
-
-    def change_states(self, checked, product_types):
-        product_types = set(product_types)
-        if not product_types:
-            return
-
-        if checked is None:
-            state = None
-        elif checked:
-            state = QtCore.Qt.Checked
-        else:
-            state = QtCore.Qt.Unchecked
-
-        self._bulk_change = True
-
-        changed = False
-        for product_type in product_types:
-            item = self._items_by_name.get(product_type)
-            if item is None:
-                continue
-            new_state = state
-            item_checkstate = item.checkState()
-            if new_state is None:
-                if item_checkstate == QtCore.Qt.Checked:
-                    new_state = QtCore.Qt.Unchecked
-                else:
-                    new_state = QtCore.Qt.Checked
-            elif item_checkstate == new_state:
-                continue
-            changed = True
-            item.setCheckState(new_state)
-
-        self._bulk_change = False
-
-        if changed:
-            self.filter_changed.emit()
-
-    def _on_controller_reset_finish(self):
-        self.refresh(self._last_project)
-
-
-class ProductTypesView(QtWidgets.QListView):
-    filter_changed = QtCore.Signal()
-
-    def __init__(self, controller, parent):
-        super(ProductTypesView, self).__init__(parent)
-
-        self.setSelectionMode(
-            QtWidgets.QAbstractItemView.ExtendedSelection
-        )
-        self.setAlternatingRowColors(True)
-        self.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
-
-        product_types_model = ProductTypesQtModel(controller)
-        product_types_proxy_model = QtCore.QSortFilterProxyModel()
-        product_types_proxy_model.setSourceModel(product_types_model)
-
-        self.setModel(product_types_proxy_model)
-
-        product_types_model.refreshed.connect(self._on_refresh_finished)
-        product_types_model.filter_changed.connect(self._on_filter_change)
-        self.customContextMenuRequested.connect(self._on_context_menu)
-
-        controller.register_event_callback(
-            "selection.project.changed",
-            self._on_project_change
-        )
-
-        self._controller = controller
-        self._refresh_product_types_filter = False
-
-        self._product_types_model = product_types_model
-        self._product_types_proxy_model = product_types_proxy_model
-
-    def get_filter_info(self):
-        return self._product_types_model.get_filter_info()
-
-    def reset_product_types_filter_on_refresh(self):
-        self._product_types_model.reset_product_types_filter_on_refresh()
-
-    def _on_project_change(self, event):
-        project_name = event["project_name"]
-        self._product_types_model.refresh(project_name)
-
-    def _on_refresh_finished(self):
-        # Apply product types filter on first show
-        self.filter_changed.emit()
-
-    def _on_filter_change(self):
-        if not self._product_types_model.is_refreshing():
-            self.filter_changed.emit()
-
-    def _change_selection_state(self, checkstate):
-        selection_model = self.selectionModel()
-        product_types = {
-            index.data(PRODUCT_TYPE_ROLE)
-            for index in selection_model.selectedIndexes()
-        }
-        product_types.discard(None)
-        self._product_types_model.change_states(checkstate, product_types)
-
-    def _on_enable_all(self):
-        self._product_types_model.change_state_for_all(True)
-
-    def _on_disable_all(self):
-        self._product_types_model.change_state_for_all(False)
-
-    def _on_context_menu(self, pos):
-        menu = QtWidgets.QMenu(self)
-
-        # Add enable all action
-        action_check_all = QtWidgets.QAction(menu)
-        action_check_all.setText("Enable All")
-        action_check_all.triggered.connect(self._on_enable_all)
-        # Add disable all action
-        action_uncheck_all = QtWidgets.QAction(menu)
-        action_uncheck_all.setText("Disable All")
-        action_uncheck_all.triggered.connect(self._on_disable_all)
-
-        menu.addAction(action_check_all)
-        menu.addAction(action_uncheck_all)
-
-        # Get mouse position
-        global_pos = self.viewport().mapToGlobal(pos)
-        menu.exec_(global_pos)
-
-    def event(self, event):
-        if event.type() == QtCore.QEvent.KeyPress:
-            if event.key() == QtCore.Qt.Key_Space:
-                self._change_selection_state(None)
-                return True
-
-            if event.key() == QtCore.Qt.Key_Backspace:
-                self._change_selection_state(False)
-                return True
-
-            if event.key() == QtCore.Qt.Key_Return:
-                self._change_selection_state(True)
-                return True
-
-        return super(ProductTypesView, self).event(event)

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

@@ -19,6 +19,7 @@ from .products_model import (
 )
 
 STATUS_NAME_ROLE = QtCore.Qt.UserRole + 1
+TASK_ID_ROLE = QtCore.Qt.UserRole + 2
 
 
 class VersionsModel(QtGui.QStandardItemModel):
@@ -48,6 +49,7 @@ class VersionsModel(QtGui.QStandardItemModel):
                 item.setData(version_id, QtCore.Qt.UserRole)
                 self._items_by_id[version_id] = item
             item.setData(version_item.status, STATUS_NAME_ROLE)
+            item.setData(version_item.task_id, TASK_ID_ROLE)
 
             if item.row() != idx:
                 root_item.insertRow(idx, item)
@@ -57,17 +59,30 @@ class VersionsFilterModel(QtCore.QSortFilterProxyModel):
     def __init__(self):
         super().__init__()
         self._status_filter = None
+        self._task_ids_filter = None
 
     def filterAcceptsRow(self, row, parent):
-        if self._status_filter is None:
-            return True
+        if self._status_filter is not None:
+            if not self._status_filter:
+                return False
 
-        if not self._status_filter:
-            return False
+            index = self.sourceModel().index(row, 0, parent)
+            status = index.data(STATUS_NAME_ROLE)
+            if status not in self._status_filter:
+                return False
 
-        index = self.sourceModel().index(row, 0, parent)
-        status = index.data(STATUS_NAME_ROLE)
-        return status in self._status_filter
+        if self._task_ids_filter:
+            index = self.sourceModel().index(row, 0, parent)
+            task_id = index.data(TASK_ID_ROLE)
+            if task_id not in self._task_ids_filter:
+                return False
+        return True
+
+    def set_tasks_filter(self, task_ids):
+        if self._task_ids_filter == task_ids:
+            return
+        self._task_ids_filter = task_ids
+        self.invalidateFilter()
 
     def set_statuses_filter(self, status_names):
         if self._status_filter == status_names:
@@ -101,6 +116,13 @@ class VersionComboBox(QtWidgets.QComboBox):
     def get_product_id(self):
         return self._product_id
 
+    def set_tasks_filter(self, task_ids):
+        self._proxy_model.set_tasks_filter(task_ids)
+        if self.count() == 0:
+            return
+        if self.currentIndex() != 0:
+            self.setCurrentIndex(0)
+
     def set_statuses_filter(self, status_names):
         self._proxy_model.set_statuses_filter(status_names)
         if self.count() == 0:
@@ -149,6 +171,7 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
         super().__init__(*args, **kwargs)
 
         self._editor_by_id: Dict[str, VersionComboBox] = {}
+        self._task_ids_filter = None
         self._statuses_filter = None
 
     def displayText(self, value, locale):
@@ -156,6 +179,11 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
             return "N/A"
         return format_version(value)
 
+    def set_tasks_filter(self, task_ids):
+        self._task_ids_filter = set(task_ids)
+        for widget in self._editor_by_id.values():
+            widget.set_tasks_filter(task_ids)
+
     def set_statuses_filter(self, status_names):
         self._statuses_filter = set(status_names)
         for widget in self._editor_by_id.values():
@@ -239,6 +267,7 @@ class VersionDelegate(QtWidgets.QStyledItemDelegate):
         version_id = index.data(VERSION_ID_ROLE)
 
         editor.update_versions(versions, version_id)
+        editor.set_tasks_filter(self._task_ids_filter)
         editor.set_statuses_filter(self._statuses_filter)
 
     def setModelData(self, editor, model, index):

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

@@ -12,34 +12,35 @@ GROUP_TYPE_ROLE = QtCore.Qt.UserRole + 1
 MERGED_COLOR_ROLE = QtCore.Qt.UserRole + 2
 FOLDER_LABEL_ROLE = QtCore.Qt.UserRole + 3
 FOLDER_ID_ROLE = QtCore.Qt.UserRole + 4
-PRODUCT_ID_ROLE = QtCore.Qt.UserRole + 5
-PRODUCT_NAME_ROLE = QtCore.Qt.UserRole + 6
-PRODUCT_TYPE_ROLE = QtCore.Qt.UserRole + 7
-PRODUCT_TYPE_ICON_ROLE = QtCore.Qt.UserRole + 8
-PRODUCT_IN_SCENE_ROLE = QtCore.Qt.UserRole + 9
-VERSION_ID_ROLE = QtCore.Qt.UserRole + 10
-VERSION_HERO_ROLE = QtCore.Qt.UserRole + 11
-VERSION_NAME_ROLE = QtCore.Qt.UserRole + 12
-VERSION_NAME_EDIT_ROLE = QtCore.Qt.UserRole + 13
-VERSION_PUBLISH_TIME_ROLE = QtCore.Qt.UserRole + 14
-VERSION_STATUS_NAME_ROLE = QtCore.Qt.UserRole + 15
-VERSION_STATUS_SHORT_ROLE = QtCore.Qt.UserRole + 16
-VERSION_STATUS_COLOR_ROLE = QtCore.Qt.UserRole + 17
-VERSION_STATUS_ICON_ROLE = QtCore.Qt.UserRole + 18
-VERSION_AUTHOR_ROLE = QtCore.Qt.UserRole + 19
-VERSION_FRAME_RANGE_ROLE = QtCore.Qt.UserRole + 20
-VERSION_DURATION_ROLE = QtCore.Qt.UserRole + 21
-VERSION_HANDLES_ROLE = QtCore.Qt.UserRole + 22
-VERSION_STEP_ROLE = QtCore.Qt.UserRole + 23
-VERSION_AVAILABLE_ROLE = QtCore.Qt.UserRole + 24
-VERSION_THUMBNAIL_ID_ROLE = QtCore.Qt.UserRole + 25
-ACTIVE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 26
-REMOTE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 27
-REPRESENTATIONS_COUNT_ROLE = QtCore.Qt.UserRole + 28
-SYNC_ACTIVE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 29
-SYNC_REMOTE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 30
+TASK_ID_ROLE = QtCore.Qt.UserRole + 5
+PRODUCT_ID_ROLE = QtCore.Qt.UserRole + 6
+PRODUCT_NAME_ROLE = QtCore.Qt.UserRole + 7
+PRODUCT_TYPE_ROLE = QtCore.Qt.UserRole + 8
+PRODUCT_TYPE_ICON_ROLE = QtCore.Qt.UserRole + 9
+PRODUCT_IN_SCENE_ROLE = QtCore.Qt.UserRole + 10
+VERSION_ID_ROLE = QtCore.Qt.UserRole + 11
+VERSION_HERO_ROLE = QtCore.Qt.UserRole + 12
+VERSION_NAME_ROLE = QtCore.Qt.UserRole + 13
+VERSION_NAME_EDIT_ROLE = QtCore.Qt.UserRole + 14
+VERSION_PUBLISH_TIME_ROLE = QtCore.Qt.UserRole + 15
+VERSION_STATUS_NAME_ROLE = QtCore.Qt.UserRole + 16
+VERSION_STATUS_SHORT_ROLE = QtCore.Qt.UserRole + 17
+VERSION_STATUS_COLOR_ROLE = QtCore.Qt.UserRole + 18
+VERSION_STATUS_ICON_ROLE = QtCore.Qt.UserRole + 19
+VERSION_AUTHOR_ROLE = QtCore.Qt.UserRole + 20
+VERSION_FRAME_RANGE_ROLE = QtCore.Qt.UserRole + 21
+VERSION_DURATION_ROLE = QtCore.Qt.UserRole + 22
+VERSION_HANDLES_ROLE = QtCore.Qt.UserRole + 23
+VERSION_STEP_ROLE = QtCore.Qt.UserRole + 24
+VERSION_AVAILABLE_ROLE = QtCore.Qt.UserRole + 25
+VERSION_THUMBNAIL_ID_ROLE = QtCore.Qt.UserRole + 26
+ACTIVE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 27
+REMOTE_SITE_ICON_ROLE = QtCore.Qt.UserRole + 28
+REPRESENTATIONS_COUNT_ROLE = QtCore.Qt.UserRole + 29
+SYNC_ACTIVE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 30
+SYNC_REMOTE_SITE_AVAILABILITY = QtCore.Qt.UserRole + 31
 
-STATUS_NAME_FILTER_ROLE = QtCore.Qt.UserRole + 31
+STATUS_NAME_FILTER_ROLE = QtCore.Qt.UserRole + 32
 
 
 class ProductsModel(QtGui.QStandardItemModel):
@@ -368,6 +369,7 @@ class ProductsModel(QtGui.QStandardItemModel):
 
         """
         model_item.setData(version_item.version_id, VERSION_ID_ROLE)
+        model_item.setData(version_item.task_id, TASK_ID_ROLE)
         model_item.setData(version_item.version, VERSION_NAME_ROLE)
         model_item.setData(version_item.is_hero, VERSION_HERO_ROLE)
         model_item.setData(

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

@@ -1,4 +1,6 @@
+from __future__ import annotations
 import collections
+from typing import Optional
 
 from qtpy import QtWidgets, QtCore
 
@@ -15,6 +17,7 @@ from .products_model import (
     GROUP_TYPE_ROLE,
     MERGED_COLOR_ROLE,
     FOLDER_ID_ROLE,
+    TASK_ID_ROLE,
     PRODUCT_ID_ROLE,
     VERSION_ID_ROLE,
     VERSION_STATUS_NAME_ROLE,
@@ -36,8 +39,9 @@ class ProductsProxyModel(RecursiveSortFilterProxyModel):
     def __init__(self, parent=None):
         super().__init__(parent)
 
-        self._product_type_filters = {}
+        self._product_type_filters = None
         self._statuses_filter = None
+        self._task_ids_filter = None
         self._ascending_sort = True
 
     def get_statuses_filter(self):
@@ -45,7 +49,15 @@ class ProductsProxyModel(RecursiveSortFilterProxyModel):
             return None
         return set(self._statuses_filter)
 
+    def set_tasks_filter(self, task_ids_filter):
+        if self._task_ids_filter == task_ids_filter:
+            return
+        self._task_ids_filter = task_ids_filter
+        self.invalidateFilter()
+
     def set_product_type_filters(self, product_type_filters):
+        if self._product_type_filters == product_type_filters:
+            return
         self._product_type_filters = product_type_filters
         self.invalidateFilter()
 
@@ -58,29 +70,41 @@ class ProductsProxyModel(RecursiveSortFilterProxyModel):
     def filterAcceptsRow(self, source_row, source_parent):
         source_model = self.sourceModel()
         index = source_model.index(source_row, 0, source_parent)
-
-        product_types_s = source_model.data(index, PRODUCT_TYPE_ROLE)
-        product_types = []
-        if product_types_s:
-            product_types = product_types_s.split("|")
-
-        for product_type in product_types:
-            if not self._product_type_filters.get(product_type, True):
-                return False
-
-        if not self._accept_row_by_statuses(index):
+        if not self._accept_task_ids_filter(index):
             return False
+
+        if not self._accept_row_by_role_value(
+            index, self._product_type_filters, PRODUCT_TYPE_ROLE
+        ):
+            return False
+
+        if not self._accept_row_by_role_value(
+            index, self._statuses_filter, STATUS_NAME_FILTER_ROLE
+        ):
+            return False
+
         return super().filterAcceptsRow(source_row, source_parent)
 
-    def _accept_row_by_statuses(self, index):
-        if self._statuses_filter is None:
+    def _accept_task_ids_filter(self, index):
+        if not self._task_ids_filter:
             return True
-        if not self._statuses_filter:
+        task_id = index.data(TASK_ID_ROLE)
+        return task_id in self._task_ids_filter
+
+    def _accept_row_by_role_value(
+        self,
+        index: QtCore.QModelIndex,
+        filter_value: Optional[set[str]],
+        role: int
+    ):
+        if filter_value is None:
+            return True
+        if not filter_value:
             return False
 
-        status_s = index.data(STATUS_NAME_FILTER_ROLE)
+        status_s = index.data(role)
         for status in status_s.split("|"):
-            if status in self._statuses_filter:
+            if status in filter_value:
                 return True
         return False
 
@@ -120,7 +144,7 @@ class ProductsWidget(QtWidgets.QWidget):
         90,   # Product type
         130,  # Folder label
         60,   # Version
-        100,   # Status
+        100,  # Status
         125,  # Time
         75,   # Author
         75,   # Frames
@@ -246,6 +270,16 @@ class ProductsWidget(QtWidgets.QWidget):
         """
         self._products_proxy_model.setFilterFixedString(name)
 
+    def set_tasks_filter(self, task_ids):
+        """Set filter of version tasks.
+
+        Args:
+            task_ids (set[str]): Task ids.
+
+        """
+        self._version_delegate.set_tasks_filter(task_ids)
+        self._products_proxy_model.set_tasks_filter(task_ids)
+
     def set_statuses_filter(self, status_names):
         """Set filter of version statuses.
 

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

@@ -1,4 +1,4 @@
-from typing import List, Dict
+from __future__ import annotations
 
 from qtpy import QtCore, QtGui
 
@@ -7,7 +7,7 @@ from ayon_core.tools.common_models import StatusItem
 
 from ._multicombobox import (
     CustomPaintMultiselectComboBox,
-    STANDARD_ITEM_TYPE,
+    BaseQtModel,
 )
 
 STATUS_ITEM_TYPE = 0
@@ -24,62 +24,43 @@ ITEM_TYPE_ROLE = QtCore.Qt.UserRole + 5
 ITEM_SUBTYPE_ROLE = QtCore.Qt.UserRole + 6
 
 
-class StatusesQtModel(QtGui.QStandardItemModel):
+class StatusesQtModel(BaseQtModel):
     def __init__(self, controller):
-        self._controller = controller
-        self._items_by_name: Dict[str, QtGui.QStandardItem] = {}
-        self._icons_by_name_n_color: Dict[str, QtGui.QIcon] = {}
-        self._last_project = None
+        self._items_by_name: dict[str, QtGui.QStandardItem] = {}
+        self._icons_by_name_n_color: dict[str, QtGui.QIcon] = {}
+        super().__init__(
+            ITEM_TYPE_ROLE,
+            ITEM_SUBTYPE_ROLE,
+            "No statuses...",
+            controller,
+        )
 
-        self._select_project_item = None
-        self._empty_statuses_item = None
+    def _get_standard_items(self) -> list[QtGui.QStandardItem]:
+        return list(self._items_by_name.values())
 
-        self._select_all_item = None
-        self._deselect_all_item = None
-        self._swap_states_item = None
+    def _clear_standard_items(self):
+        self._items_by_name.clear()
 
-        super().__init__()
-
-        self.refresh(None)
-
-    def get_placeholder_text(self):
-        return self._placeholder
-
-    def refresh(self, project_name):
-        # New project was selected
-        #   status filter is reset to show all statuses
-        uncheck_all = False
-        if project_name != self._last_project:
-            self._last_project = project_name
-            uncheck_all = True
-
-        if project_name is None:
-            self._add_select_project_item()
-            return
-
-        status_items: List[StatusItem] = (
+    def _prepare_new_value_items(
+        self, project_name: str, project_changed: bool
+    ):
+        status_items: list[StatusItem] = (
             self._controller.get_project_status_items(
                 project_name, sender=STATUSES_FILTER_SENDER
             )
         )
+        items = []
+        items_to_remove = []
         if not status_items:
-            self._add_empty_statuses_item()
-            return
+            return items, items_to_remove
 
-        self._remove_empty_items()
-
-        items_to_remove = set(self._items_by_name)
-        root_item = self.invisibleRootItem()
+        names_to_remove = set(self._items_by_name)
         for row_idx, status_item in enumerate(status_items):
             name = status_item.name
             if name in self._items_by_name:
-                is_new = False
                 item = self._items_by_name[name]
-                if uncheck_all:
-                    item.setCheckState(QtCore.Qt.Unchecked)
-                items_to_remove.discard(name)
+                names_to_remove.discard(name)
             else:
-                is_new = True
                 item = QtGui.QStandardItem()
                 item.setData(ITEM_SUBTYPE_ROLE, STATUS_ITEM_TYPE)
                 item.setCheckState(QtCore.Qt.Unchecked)
@@ -100,36 +81,14 @@ class StatusesQtModel(QtGui.QStandardItemModel):
                 if item.data(role) != value:
                     item.setData(value, role)
 
-            if is_new:
-                root_item.insertRow(row_idx, item)
+            if project_changed:
+                item.setCheckState(QtCore.Qt.Unchecked)
+            items.append(item)
 
-        for name in items_to_remove:
-            item = self._items_by_name.pop(name)
-            root_item.removeRow(item.row())
+        for name in names_to_remove:
+            items_to_remove.append(self._items_by_name.pop(name))
 
-        self._add_selection_items()
-
-    def setData(self, index, value, role):
-        if role == QtCore.Qt.CheckStateRole and index.isValid():
-            item_type = index.data(ITEM_SUBTYPE_ROLE)
-            if item_type == SELECT_ALL_TYPE:
-                for item in self._items_by_name.values():
-                    item.setCheckState(QtCore.Qt.Checked)
-                return True
-            if item_type == DESELECT_ALL_TYPE:
-                for item in self._items_by_name.values():
-                    item.setCheckState(QtCore.Qt.Unchecked)
-                return True
-            if item_type == SWAP_STATE_TYPE:
-                for item in self._items_by_name.values():
-                    current_state = item.checkState()
-                    item.setCheckState(
-                        QtCore.Qt.Checked
-                        if current_state == QtCore.Qt.Unchecked
-                        else QtCore.Qt.Unchecked
-                    )
-                return True
-        return super().setData(index, value, role)
+        return items, items_to_remove
 
     def _get_icon(self, status_item: StatusItem) -> QtGui.QIcon:
         name = status_item.name
@@ -147,139 +106,6 @@ class StatusesQtModel(QtGui.QStandardItemModel):
         self._icons_by_name_n_color[unique_id] = icon
         return icon
 
-    def _init_default_items(self):
-        if self._empty_statuses_item is not None:
-            return
-
-        empty_statuses_item = QtGui.QStandardItem("No statuses...")
-        select_project_item = QtGui.QStandardItem("Select project...")
-
-        select_all_item = QtGui.QStandardItem("Select all")
-        deselect_all_item = QtGui.QStandardItem("Deselect all")
-        swap_states_item = QtGui.QStandardItem("Swap")
-
-        for item in (
-            empty_statuses_item,
-            select_project_item,
-            select_all_item,
-            deselect_all_item,
-            swap_states_item,
-        ):
-            item.setData(STANDARD_ITEM_TYPE, ITEM_TYPE_ROLE)
-
-        select_all_item.setIcon(get_qt_icon({
-            "type": "material-symbols",
-            "name": "done_all",
-            "color": "white"
-        }))
-        deselect_all_item.setIcon(get_qt_icon({
-            "type": "material-symbols",
-            "name": "remove_done",
-            "color": "white"
-        }))
-        swap_states_item.setIcon(get_qt_icon({
-            "type": "material-symbols",
-            "name": "swap_horiz",
-            "color": "white"
-        }))
-
-        for item in (
-            empty_statuses_item,
-            select_project_item,
-        ):
-            item.setFlags(QtCore.Qt.NoItemFlags)
-
-        for item, item_type in (
-            (select_all_item, SELECT_ALL_TYPE),
-            (deselect_all_item, DESELECT_ALL_TYPE),
-            (swap_states_item, SWAP_STATE_TYPE),
-        ):
-            item.setData(item_type, ITEM_SUBTYPE_ROLE)
-
-        for item in (
-            select_all_item,
-            deselect_all_item,
-            swap_states_item,
-        ):
-            item.setFlags(
-                QtCore.Qt.ItemIsEnabled
-                | QtCore.Qt.ItemIsSelectable
-                | QtCore.Qt.ItemIsUserCheckable
-            )
-
-        self._empty_statuses_item = empty_statuses_item
-        self._select_project_item = select_project_item
-
-        self._select_all_item = select_all_item
-        self._deselect_all_item = deselect_all_item
-        self._swap_states_item = swap_states_item
-
-    def _get_empty_statuses_item(self):
-        self._init_default_items()
-        return self._empty_statuses_item
-
-    def _get_select_project_item(self):
-        self._init_default_items()
-        return self._select_project_item
-
-    def _get_empty_items(self):
-        self._init_default_items()
-        return [
-            self._empty_statuses_item,
-            self._select_project_item,
-        ]
-
-    def _get_selection_items(self):
-        self._init_default_items()
-        return [
-            self._select_all_item,
-            self._deselect_all_item,
-            self._swap_states_item,
-        ]
-
-    def _get_default_items(self):
-        return self._get_empty_items() + self._get_selection_items()
-
-    def _add_select_project_item(self):
-        item = self._get_select_project_item()
-        if item.row() < 0:
-            self._remove_items()
-            root_item = self.invisibleRootItem()
-            root_item.appendRow(item)
-
-    def _add_empty_statuses_item(self):
-        item = self._get_empty_statuses_item()
-        if item.row() < 0:
-            self._remove_items()
-            root_item = self.invisibleRootItem()
-            root_item.appendRow(item)
-
-    def _add_selection_items(self):
-        root_item = self.invisibleRootItem()
-        items = self._get_selection_items()
-        for item in self._get_selection_items():
-            row = item.row()
-            if row >= 0:
-                root_item.takeRow(row)
-        root_item.appendRows(items)
-
-    def _remove_items(self):
-        root_item = self.invisibleRootItem()
-        for item in self._get_default_items():
-            if item.row() < 0:
-                continue
-            root_item.takeRow(item.row())
-
-        root_item.removeRows(0, root_item.rowCount())
-        self._items_by_name.clear()
-
-    def _remove_empty_items(self):
-        root_item = self.invisibleRootItem()
-        for item in self._get_empty_items():
-            if item.row() < 0:
-                continue
-            root_item.takeRow(item.row())
-
 
 class StatusesCombobox(CustomPaintMultiselectComboBox):
     def __init__(self, controller, parent):

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

@@ -0,0 +1,405 @@
+import collections
+import hashlib
+
+from qtpy import QtWidgets, QtCore, QtGui
+
+from ayon_core.style import get_default_entity_icon_color
+from ayon_core.tools.utils import (
+    RecursiveSortFilterProxyModel,
+    DeselectableTreeView,
+    TasksQtModel,
+    TASKS_MODEL_SENDER_NAME,
+)
+from ayon_core.tools.utils.tasks_widget import (
+    ITEM_ID_ROLE,
+    ITEM_NAME_ROLE,
+    PARENT_ID_ROLE,
+    TASK_TYPE_ROLE,
+)
+from ayon_core.tools.utils.lib import RefreshThread, get_qt_icon
+
+# Role that can't clash with default 'tasks_widget' roles
+FOLDER_LABEL_ROLE = QtCore.Qt.UserRole + 100
+NO_TASKS_ID = "--no-task--"
+
+
+class LoaderTasksQtModel(TasksQtModel):
+    column_labels = [
+        "Task name",
+        "Task type",
+        "Folder"
+    ]
+
+    def __init__(self, controller):
+        super().__init__(controller)
+
+        self._items_by_id = {}
+        self._groups_by_name = {}
+        self._last_folder_ids = set()
+        # This item is used to be able filter versions without any task
+        # - do not mismatch with '_empty_tasks_item' item from 'TasksQtModel'
+        self._no_tasks_item = None
+
+    def refresh(self):
+        """Refresh tasks for selected folders."""
+
+        self._refresh(self._last_project_name, self._last_folder_ids)
+
+    def set_context(self, project_name, folder_ids):
+        self._refresh(project_name, folder_ids)
+
+    # Mark some functions from 'TasksQtModel' as not implemented
+    def get_index_by_name(self, task_name):
+        raise NotImplementedError(
+            "Method 'get_index_by_name' is not implemented."
+        )
+
+    def get_last_folder_id(self):
+        raise NotImplementedError(
+            "Method 'get_last_folder_id' is not implemented."
+        )
+
+    def flags(self, index):
+        if index.column() != 0:
+            index = self.index(index.row(), 0, index.parent())
+        return super().flags(index)
+
+    def _get_no_tasks_item(self):
+        if self._no_tasks_item is None:
+            item = QtGui.QStandardItem("No task")
+            icon = get_qt_icon({
+                "type": "material-symbols",
+                "name": "indeterminate_check_box",
+                "color": get_default_entity_icon_color(),
+            })
+            item.setData(icon, QtCore.Qt.DecorationRole)
+            item.setData(NO_TASKS_ID, ITEM_ID_ROLE)
+            item.setEditable(False)
+            self._no_tasks_item = item
+        return self._no_tasks_item
+
+    def _refresh(self, project_name, folder_ids):
+        self._is_refreshing = True
+        self._last_project_name = project_name
+        self._last_folder_ids = folder_ids
+        if not folder_ids:
+            self._add_invalid_selection_item()
+            self._current_refresh_thread = None
+            self._is_refreshing = False
+            self.refreshed.emit()
+            return
+
+        thread_id = hashlib.sha256(
+            "|".join(sorted(folder_ids)).encode()
+        ).hexdigest()
+        thread = self._refresh_threads.get(thread_id)
+        if thread is not None:
+            self._current_refresh_thread = thread
+            return
+        thread = RefreshThread(
+            thread_id,
+            self._thread_getter,
+            project_name,
+            folder_ids
+        )
+        self._current_refresh_thread = thread
+        self._refresh_threads[thread.id] = thread
+        thread.refresh_finished.connect(self._on_refresh_thread)
+        thread.start()
+
+    def _thread_getter(self, project_name, folder_ids):
+        task_items = self._controller.get_task_items(
+            project_name, folder_ids, sender=TASKS_MODEL_SENDER_NAME
+        )
+        task_type_items = {}
+        if hasattr(self._controller, "get_task_type_items"):
+            task_type_items = self._controller.get_task_type_items(
+                project_name, sender=TASKS_MODEL_SENDER_NAME
+            )
+        folder_ids = {
+            task_item.parent_id
+            for task_item in task_items
+        }
+        folder_labels_by_id = self._controller.get_folder_labels(
+            project_name, folder_ids
+        )
+        return task_items, task_type_items, folder_labels_by_id
+
+    def _on_refresh_thread(self, thread_id):
+        """Callback when refresh thread is finished.
+
+        Technically can be running multiple refresh threads at the same time,
+        to avoid using values from wrong thread, we check if thread id is
+        current refresh thread id.
+
+        Tasks are stored by name, so if a folder has same task name as
+        previously selected folder it keeps the selection.
+
+        Args:
+            thread_id (str): Thread id.
+        """
+
+        # Make sure to remove thread from '_refresh_threads' dict
+        thread = self._refresh_threads.pop(thread_id)
+        if (
+            self._current_refresh_thread is None
+            or thread_id != self._current_refresh_thread.id
+        ):
+            return
+
+        self._fill_data_from_thread(thread)
+
+        root_item = self.invisibleRootItem()
+        self._has_content = root_item.rowCount() > 0
+        self._current_refresh_thread = None
+        self._is_refreshing = False
+        self.refreshed.emit()
+
+    def _clear_items(self):
+        self._items_by_id = {}
+        self._groups_by_name = {}
+        super()._clear_items()
+
+    def _fill_data_from_thread(self, thread):
+        task_items, task_type_items, folder_labels_by_id = thread.get_result()
+        # Task items are refreshed
+        if task_items is None:
+            return
+
+        # No tasks are available on folder
+        if not task_items:
+            self._add_empty_task_item()
+            return
+        self._remove_invalid_items()
+
+        task_type_item_by_name = {
+            task_type_item.name: task_type_item
+            for task_type_item in task_type_items
+        }
+        task_type_icon_cache = {}
+        current_ids = set()
+        items_by_name = collections.defaultdict(list)
+        for task_item in task_items:
+            task_id = task_item.task_id
+            current_ids.add(task_id)
+            item = self._items_by_id.get(task_id)
+            if item is None:
+                item = QtGui.QStandardItem()
+                item.setColumnCount(self.columnCount())
+                item.setEditable(False)
+                self._items_by_id[task_id] = item
+
+            icon = self._get_task_item_icon(
+                task_item,
+                task_type_item_by_name,
+                task_type_icon_cache
+            )
+            name = task_item.name
+            folder_id = task_item.parent_id
+            folder_label = folder_labels_by_id.get(folder_id)
+
+            item.setData(name, QtCore.Qt.DisplayRole)
+            item.setData(name, ITEM_NAME_ROLE)
+            item.setData(task_item.id, ITEM_ID_ROLE)
+            item.setData(task_item.task_type, TASK_TYPE_ROLE)
+            item.setData(folder_id, PARENT_ID_ROLE)
+            item.setData(folder_label, FOLDER_LABEL_ROLE)
+            item.setData(icon, QtCore.Qt.DecorationRole)
+
+            items_by_name[name].append(item)
+
+        root_item = self.invisibleRootItem()
+
+        # Make sure item is not parented
+        # - this is laziness to avoid re-parenting items which does
+        #   complicate the code with no benefit
+        queue = collections.deque()
+        queue.append((None, root_item))
+        while queue:
+            (parent, item) = queue.popleft()
+            if not item.hasChildren():
+                if parent:
+                    parent.takeRow(item.row())
+                continue
+
+            for row in range(item.rowCount()):
+                queue.append((item, item.child(row, 0)))
+
+            queue.append((parent, item))
+
+        used_group_names = set()
+        new_root_items = [
+            self._get_no_tasks_item()
+        ]
+        for name, items in items_by_name.items():
+            if len(items) == 1:
+                new_root_items.extend(items)
+                continue
+
+            used_group_names.add(name)
+            group_item = self._groups_by_name.get(name)
+            if group_item is None:
+                group_item = QtGui.QStandardItem()
+                group_item.setData(name, QtCore.Qt.DisplayRole)
+                group_item.setEditable(False)
+                group_item.setColumnCount(self.columnCount())
+                self._groups_by_name[name] = group_item
+
+            # Use icon from first item
+            first_item_icon = items[0].data(QtCore.Qt.DecorationRole)
+            task_ids = [
+                item.data(ITEM_ID_ROLE)
+                for item in items
+            ]
+
+            group_item.setData(first_item_icon, QtCore.Qt.DecorationRole)
+            group_item.setData("|".join(task_ids), ITEM_ID_ROLE)
+
+            group_item.appendRows(items)
+
+            new_root_items.append(group_item)
+
+        # Remove unused caches
+        for task_id in set(self._items_by_id) - current_ids:
+            self._items_by_id.pop(task_id)
+
+        for name in set(self._groups_by_name) - used_group_names:
+            self._groups_by_name.pop(name)
+
+        if new_root_items:
+            root_item.appendRows(new_root_items)
+
+    def data(self, index, role=None):
+        if not index.isValid():
+            return None
+
+        if role is None:
+            role = QtCore.Qt.DisplayRole
+
+        col = index.column()
+        if col != 0:
+            index = self.index(index.row(), 0, index.parent())
+
+        if col == 1:
+            if role == QtCore.Qt.DisplayRole:
+                role = TASK_TYPE_ROLE
+            else:
+                return None
+
+        if col == 2:
+            if role == QtCore.Qt.DisplayRole:
+                role = FOLDER_LABEL_ROLE
+            else:
+                return None
+
+        return super().data(index, role)
+
+
+class LoaderTasksProxyModel(RecursiveSortFilterProxyModel):
+    def lessThan(self, left, right):
+        if left.data(ITEM_ID_ROLE) == NO_TASKS_ID:
+            return False
+        if right.data(ITEM_ID_ROLE) == NO_TASKS_ID:
+            return True
+        return super().lessThan(left, right)
+
+
+class LoaderTasksWidget(QtWidgets.QWidget):
+    refreshed = QtCore.Signal()
+
+    def __init__(self, controller, parent):
+        super().__init__(parent)
+
+        tasks_view = DeselectableTreeView(self)
+        tasks_view.setSelectionMode(
+            QtWidgets.QAbstractItemView.ExtendedSelection
+        )
+
+        tasks_model = LoaderTasksQtModel(controller)
+        tasks_proxy_model = LoaderTasksProxyModel()
+        tasks_proxy_model.setSourceModel(tasks_model)
+        tasks_proxy_model.setSortCaseSensitivity(QtCore.Qt.CaseInsensitive)
+
+        tasks_view.setModel(tasks_proxy_model)
+        # Hide folder column by default
+        tasks_view.setColumnHidden(2, True)
+
+        main_layout = QtWidgets.QHBoxLayout(self)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+        main_layout.addWidget(tasks_view, 1)
+
+        controller.register_event_callback(
+            "selection.folders.changed",
+            self._on_folders_selection_changed,
+        )
+        controller.register_event_callback(
+            "tasks.refresh.finished",
+            self._on_tasks_refresh_finished
+        )
+
+        selection_model = tasks_view.selectionModel()
+        selection_model.selectionChanged.connect(self._on_selection_change)
+
+        tasks_model.refreshed.connect(self._on_model_refresh)
+
+        self._controller = controller
+        self._tasks_view = tasks_view
+        self._tasks_model = tasks_model
+        self._tasks_proxy_model = tasks_proxy_model
+
+        self._fisrt_show = True
+
+    def showEvent(self, event):
+        super().showEvent(event)
+        if self._fisrt_show:
+            self._fisrt_show = False
+            header_widget = self._tasks_view.header()
+            header_widget.resizeSection(0, 200)
+
+    def set_name_filter(self, name):
+        """Set filter of folder name.
+
+        Args:
+            name (str): The string filter.
+
+        """
+        self._tasks_proxy_model.setFilterFixedString(name)
+        if name:
+            self._tasks_view.expandAll()
+
+    def refresh(self):
+        self._tasks_model.refresh()
+
+    def _clear(self):
+        self._tasks_model.clear()
+
+    def _on_tasks_refresh_finished(self, event):
+        if event["sender"] != TASKS_MODEL_SENDER_NAME:
+            self._set_project_name(event["project_name"])
+
+    def _on_folders_selection_changed(self, event):
+        project_name = event["project_name"]
+        folder_ids = event["folder_ids"]
+        self._tasks_view.setColumnHidden(2, len(folder_ids) == 1)
+        self._tasks_model.set_context(project_name, folder_ids)
+
+    def _on_model_refresh(self):
+        self._tasks_proxy_model.sort(0)
+        self.refreshed.emit()
+
+    def _get_selected_item_ids(self):
+        selection_model = self._tasks_view.selectionModel()
+        item_ids = set()
+        for index in selection_model.selectedIndexes():
+            item_id = index.data(ITEM_ID_ROLE)
+            if item_id is None:
+                continue
+            if item_id == NO_TASKS_ID:
+                item_ids.add(None)
+            else:
+                item_ids |= set(item_id.split("|"))
+        return item_ids
+
+    def _on_selection_change(self):
+        item_ids = self._get_selected_item_ids()
+        self._controller.set_selected_tasks(item_ids)

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

@@ -14,8 +14,9 @@ from ayon_core.tools.utils import ProjectsCombobox
 from ayon_core.tools.loader.control import LoaderController
 
 from .folders_widget import LoaderFoldersWidget
+from .tasks_widget import LoaderTasksWidget
 from .products_widget import ProductsWidget
-from .product_types_widget import ProductTypesView
+from .product_types_combo import ProductTypesCombobox
 from .product_group_dialog import ProductGroupDialog
 from .info_widget import InfoWidget
 from .repres_widget import RepresentationsWidget
@@ -164,16 +165,16 @@ class LoaderWindow(QtWidgets.QWidget):
 
         folders_widget = LoaderFoldersWidget(controller, context_widget)
 
-        product_types_widget = ProductTypesView(controller, context_splitter)
-
         context_layout = QtWidgets.QVBoxLayout(context_widget)
         context_layout.setContentsMargins(0, 0, 0, 0)
         context_layout.addWidget(context_top_widget, 0)
         context_layout.addWidget(folders_filter_input, 0)
         context_layout.addWidget(folders_widget, 1)
 
+        tasks_widget = LoaderTasksWidget(controller, context_widget)
+
         context_splitter.addWidget(context_widget)
-        context_splitter.addWidget(product_types_widget)
+        context_splitter.addWidget(tasks_widget)
         context_splitter.setStretchFactor(0, 65)
         context_splitter.setStretchFactor(1, 35)
 
@@ -185,6 +186,10 @@ class LoaderWindow(QtWidgets.QWidget):
         products_filter_input = PlaceholderLineEdit(products_inputs_widget)
         products_filter_input.setPlaceholderText("Product name filter...")
 
+        product_types_filter_combo = ProductTypesCombobox(
+            controller, products_inputs_widget
+        )
+
         product_status_filter_combo = StatusesCombobox(controller, self)
 
         product_group_checkbox = QtWidgets.QCheckBox(
@@ -196,6 +201,7 @@ class LoaderWindow(QtWidgets.QWidget):
         products_inputs_layout = QtWidgets.QHBoxLayout(products_inputs_widget)
         products_inputs_layout.setContentsMargins(0, 0, 0, 0)
         products_inputs_layout.addWidget(products_filter_input, 1)
+        products_inputs_layout.addWidget(product_types_filter_combo, 1)
         products_inputs_layout.addWidget(product_status_filter_combo, 1)
         products_inputs_layout.addWidget(product_group_checkbox, 0)
 
@@ -244,12 +250,12 @@ class LoaderWindow(QtWidgets.QWidget):
         folders_filter_input.textChanged.connect(
             self._on_folder_filter_change
         )
-        product_types_widget.filter_changed.connect(
-            self._on_product_type_filter_change
-        )
         products_filter_input.textChanged.connect(
             self._on_product_filter_change
         )
+        product_types_filter_combo.value_changed.connect(
+            self._on_product_type_filter_change
+        )
         product_status_filter_combo.value_changed.connect(
             self._on_status_filter_change
         )
@@ -280,6 +286,10 @@ class LoaderWindow(QtWidgets.QWidget):
             "selection.folders.changed",
             self._on_folders_selection_changed,
         )
+        controller.register_event_callback(
+            "selection.tasks.changed",
+            self._on_tasks_selection_change,
+        )
         controller.register_event_callback(
             "selection.versions.changed",
             self._on_versions_selection_changed,
@@ -304,9 +314,10 @@ class LoaderWindow(QtWidgets.QWidget):
         self._folders_filter_input = folders_filter_input
         self._folders_widget = folders_widget
 
-        self._product_types_widget = product_types_widget
+        self._tasks_widget = tasks_widget
 
         self._products_filter_input = products_filter_input
+        self._product_types_filter_combo = product_types_filter_combo
         self._product_status_filter_combo = product_status_filter_combo
         self._product_group_checkbox = product_group_checkbox
         self._products_widget = products_widget
@@ -335,7 +346,7 @@ class LoaderWindow(QtWidgets.QWidget):
         self._controller.reset()
 
     def showEvent(self, event):
-        super(LoaderWindow, self).showEvent(event)
+        super().showEvent(event)
 
         if self._first_show:
             self._on_first_show()
@@ -343,9 +354,13 @@ class LoaderWindow(QtWidgets.QWidget):
         self._show_timer.start()
 
     def closeEvent(self, event):
-        super(LoaderWindow, self).closeEvent(event)
+        super().closeEvent(event)
 
-        self._product_types_widget.reset_product_types_filter_on_refresh()
+        (
+            self
+            ._product_types_filter_combo
+            .reset_product_types_filter_on_refresh()
+        )
 
         self._reset_on_show = True
 
@@ -363,7 +378,7 @@ class LoaderWindow(QtWidgets.QWidget):
             event.setAccepted(True)
             return
 
-        super(LoaderWindow, self).keyPressEvent(event)
+        super().keyPressEvent(event)
 
     def _on_first_show(self):
         self._first_show = False
@@ -423,14 +438,16 @@ class LoaderWindow(QtWidgets.QWidget):
     def _on_product_filter_change(self, text):
         self._products_widget.set_name_filter(text)
 
+    def _on_tasks_selection_change(self, event):
+        self._products_widget.set_tasks_filter(event["task_ids"])
+
     def _on_status_filter_change(self):
         status_names = self._product_status_filter_combo.get_value()
         self._products_widget.set_statuses_filter(status_names)
 
     def _on_product_type_filter_change(self):
-        self._products_widget.set_product_type_filter(
-            self._product_types_widget.get_filter_info()
-        )
+        product_types = self._product_types_filter_combo.get_value()
+        self._products_widget.set_product_type_filter(product_types)
 
     def _on_merged_products_selection_change(self):
         items = self._products_widget.get_selected_merged_products()

client/ayon_core/tools/pyblish_pype/model.py

@@ -31,7 +31,6 @@ from . import settings, util
 from .awesome import tags as awesome
 from qtpy import QtCore, QtGui
 import qtawesome
-from six import text_type
 from .constants import PluginStates, InstanceStates, GroupStates, Roles
 
 
@@ -985,7 +984,7 @@ class TerminalModel(QtGui.QStandardItemModel):
                     record_item = record
                 else:
                     record_item = {
-                        "label": text_type(record.msg),
+                        "label": str(record.msg),
                         "type": "record",
                         "levelno": record.levelno,
                         "threadName": record.threadName,
@@ -993,7 +992,7 @@ class TerminalModel(QtGui.QStandardItemModel):
                         "filename": record.filename,
                         "pathname": record.pathname,
                         "lineno": record.lineno,
-                        "msg": text_type(record.msg),
+                        "msg": str(record.msg),
                         "msecs": record.msecs,
                         "levelname": record.levelname
                     }

client/ayon_core/tools/pyblish_pype/util.py

@@ -10,7 +10,6 @@ import sys
 import collections
 
 from qtpy import QtCore
-from six import text_type
 import pyblish.api
 
 root = os.path.dirname(__file__)
@@ -64,7 +63,7 @@ def u_print(msg, **kwargs):
         **kwargs: Keyword argument for `print` function.
     """
 
-    if isinstance(msg, text_type):
+    if isinstance(msg, str):
         encoding = None
         try:
             encoding = os.getenv('PYTHONIOENCODING', sys.stdout.encoding)

client/ayon_core/tools/pyblish_pype/vendor/qtawesome/iconic_font.py

@@ -5,7 +5,6 @@ from __future__ import print_function
 import json
 import os
 
-import six
 from qtpy import QtCore, QtGui
 
 
@@ -152,7 +151,7 @@ class IconicFont(QtCore.QObject):
         def hook(obj):
             result = {}
             for key in obj:
-                result[key] = six.unichr(int(obj[key], 16))
+                result[key] = chr(int(obj[key], 16))
             return result
 
         if directory is None:

client/ayon_core/tools/utils/host_tools.py

@@ -7,7 +7,7 @@ import os
 
 import pyblish.api
 
-from ayon_core.host import ILoadHost
+from ayon_core.host import ILoadHost, IPublishHost
 from ayon_core.lib import Logger
 from ayon_core.pipeline import registered_host
 
@@ -236,7 +236,7 @@ class HostToolsHelper:
             from ayon_core.tools.publisher.window import PublisherWindow
 
             host = registered_host()
-            ILoadHost.validate_load_methods(host)
+            IPublishHost.validate_publish_methods(host)
 
             publisher_window = PublisherWindow(
                 controller=controller,

client/ayon_core/tools/utils/tasks_widget.py

@@ -24,9 +24,14 @@ class TasksQtModel(QtGui.QStandardItemModel):
     """
     _default_task_icon = None
     refreshed = QtCore.Signal()
+    column_labels = ["Tasks"]
 
     def __init__(self, controller):
-        super(TasksQtModel, self).__init__()
+        super().__init__()
+
+        self.setColumnCount(len(self.column_labels))
+        for idx, label in enumerate(self.column_labels):
+            self.setHeaderData(idx, QtCore.Qt.Horizontal, label)
 
         self._controller = controller
 
@@ -53,7 +58,8 @@ class TasksQtModel(QtGui.QStandardItemModel):
         self._has_content = False
         self._remove_invalid_items()
         root_item = self.invisibleRootItem()
-        root_item.removeRows(0, root_item.rowCount())
+        while root_item.rowCount() != 0:
+            root_item.takeRow(0)
 
     def refresh(self):
         """Refresh tasks for last project and folder."""
@@ -336,19 +342,6 @@ class TasksQtModel(QtGui.QStandardItemModel):
 
         return self._has_content
 
-    def headerData(self, section, orientation, role):
-        # Show nice labels in the header
-        if (
-            role == QtCore.Qt.DisplayRole
-            and orientation == QtCore.Qt.Horizontal
-        ):
-            if section == 0:
-                return "Tasks"
-
-        return super(TasksQtModel, self).headerData(
-            section, orientation, role
-        )
-
 
 class TasksWidget(QtWidgets.QWidget):
     """Tasks widget.
@@ -365,7 +358,7 @@ class TasksWidget(QtWidgets.QWidget):
     selection_changed = QtCore.Signal()
 
     def __init__(self, controller, parent, handle_expected_selection=False):
-        super(TasksWidget, self).__init__(parent)
+        super().__init__(parent)
 
         tasks_view = DeselectableTreeView(self)
         tasks_view.setIndentation(0)

client/ayon_core/tools/utils/views.py

@@ -7,7 +7,6 @@ class DeselectableTreeView(QtWidgets.QTreeView):
     """A tree view that deselects on clicking on an empty area in the view"""
 
     def mousePressEvent(self, event):
-
         index = self.indexAt(event.pos())
         if not index.isValid():
             # clear the selection
@@ -15,7 +14,14 @@ class DeselectableTreeView(QtWidgets.QTreeView):
             # clear the current index
             self.setCurrentIndex(QtCore.QModelIndex())
 
-        QtWidgets.QTreeView.mousePressEvent(self, event)
+        elif (
+            self.selectionModel().isSelected(index)
+            and len(self.selectionModel().selectedRows()) == 1
+            and event.modifiers() == QtCore.Qt.NoModifier
+        ):
+            event.setModifiers(QtCore.Qt.ControlModifier)
+
+        super().mousePressEvent(event)
 
 
 class TreeView(QtWidgets.QTreeView):

client/ayon_core/version.py

@@ -1,3 +1,3 @@
 # -*- coding: utf-8 -*-
 """Package declaring AYON addon 'core' version."""
-__version__ = "1.1.0+dev"
+__version__ = "1.1.3+dev"

package.py

@@ -1,6 +1,6 @@
 name = "core"
 title = "Core"
-version = "1.1.0+dev"
+version = "1.1.3+dev"
 
 client_dir = "ayon_core"
 

poetry.lock

@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 1.8.2 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.1.1 and should not be changed by hand.
 
 [[package]]
 name = "appdirs"
@@ -6,37 +6,59 @@ version = "1.4.4"
 description = "A small Python module for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
 optional = false
 python-versions = "*"
+groups = ["dev"]
 files = [
     {file = "appdirs-1.4.4-py2.py3-none-any.whl", hash = "sha256:a841dacd6b99318a741b166adb07e19ee71a274450e68237b4650ca1055ab128"},
     {file = "appdirs-1.4.4.tar.gz", hash = "sha256:7d5d0167b2b1ba821647616af46a749d1c653740dd0d2415100fe26e27afdf41"},
 ]
 
+[[package]]
+name = "attrs"
+version = "25.1.0"
+description = "Classes Without Boilerplate"
+optional = false
+python-versions = ">=3.8"
+groups = ["dev"]
+files = [
+    {file = "attrs-25.1.0-py3-none-any.whl", hash = "sha256:c75a69e28a550a7e93789579c22aa26b0f5b83b75dc4e08fe092980051e1090a"},
+    {file = "attrs-25.1.0.tar.gz", hash = "sha256:1c97078a80c814273a76b2a298a932eb681c87415c11dee0a6921de7f1b02c3e"},
+]
+
+[package.extras]
+benchmark = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
+cov = ["cloudpickle ; platform_python_implementation == \"CPython\"", "coverage[toml] (>=5.3)", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
+dev = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pre-commit-uv", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
+docs = ["cogapp", "furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-towncrier", "towncrier (<24.7)"]
+tests = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"]
+tests-mypy = ["mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\""]
+
 [[package]]
 name = "ayon-python-api"
-version = "1.0.1"
+version = "1.0.12"
 description = "AYON Python API"
 optional = false
 python-versions = "*"
+groups = ["dev"]
 files = [
-    {file = "ayon-python-api-1.0.1.tar.gz", hash = "sha256:6a53af84903317e2097f3c6bba0094e90d905d6670fb9c7d3ad3aa9de6552bc1"},
-    {file = "ayon_python_api-1.0.1-py3-none-any.whl", hash = "sha256:d4b649ac39c9003cdbd60f172c0d35f05d310fba3a0649b6d16300fe67f967d6"},
+    {file = "ayon-python-api-1.0.12.tar.gz", hash = "sha256:8e4c03436df8afdda4c6ad4efce436068771995bb0153a90e003364afa0e7f55"},
+    {file = "ayon_python_api-1.0.12-py3-none-any.whl", hash = "sha256:65f61c2595dd6deb26fed5e3fda7baef887f475fa4b21df12513646ddccf4a7d"},
 ]
 
 [package.dependencies]
 appdirs = ">=1,<2"
 requests = ">=2.27.1"
-six = ">=1.15"
-Unidecode = ">=1.2.0"
+Unidecode = ">=1.3.0"
 
 [[package]]
 name = "certifi"
-version = "2024.2.2"
+version = "2025.1.31"
 description = "Python package for providing Mozilla's CA Bundle."
 optional = false
 python-versions = ">=3.6"
+groups = ["dev"]
 files = [
-    {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"},
-    {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"},
+    {file = "certifi-2025.1.31-py3-none-any.whl", hash = "sha256:ca78db4565a652026a4db2bcdf68f2fb589ea80d0be70e03929ed730746b84fe"},
+    {file = "certifi-2025.1.31.tar.gz", hash = "sha256:3d5da6925056f6f18f119200434a4780a94263f10d1c21d032a6f6b2baa20651"},
 ]
 
 [[package]]
@@ -45,6 +67,7 @@ version = "3.4.0"
 description = "Validate configuration and produce human readable error messages."
 optional = false
 python-versions = ">=3.8"
+groups = ["dev"]
 files = [
     {file = "cfgv-3.4.0-py2.py3-none-any.whl", hash = "sha256:b7265b1f29fd3316bfcd2b330d63d024f2bfd8bcb8b0272f8e19a504856c48f9"},
     {file = "cfgv-3.4.0.tar.gz", hash = "sha256:e52591d4c5f5dead8e0f673fb16db7949d2cfb3f7da4582893288f0ded8fe560"},
@@ -52,118 +75,139 @@ files = [
 
 [[package]]
 name = "charset-normalizer"
-version = "3.3.2"
+version = "3.4.1"
 description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet."
 optional = false
-python-versions = ">=3.7.0"
+python-versions = ">=3.7"
+groups = ["dev"]
 files = [
-    {file = "charset-normalizer-3.3.2.tar.gz", hash = "sha256:f30c3cb33b24454a82faecaf01b19c18562b1e89558fb6c56de4d9118a032fd5"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:25baf083bf6f6b341f4121c2f3c548875ee6f5339300e08be3f2b2ba1721cdd3"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:06435b539f889b1f6f4ac1758871aae42dc3a8c0e24ac9e60c2384973ad73027"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9063e24fdb1e498ab71cb7419e24622516c4a04476b17a2dab57e8baa30d6e03"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6897af51655e3691ff853668779c7bad41579facacf5fd7253b0133308cf000d"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1d3193f4a680c64b4b6a9115943538edb896edc190f0b222e73761716519268e"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd70574b12bb8a4d2aaa0094515df2463cb429d8536cfb6c7ce983246983e5a6"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8465322196c8b4d7ab6d1e049e4c5cb460d0394da4a27d23cc242fbf0034b6b5"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a9a8e9031d613fd2009c182b69c7b2c1ef8239a0efb1df3f7c8da66d5dd3d537"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:beb58fe5cdb101e3a055192ac291b7a21e3b7ef4f67fa1d74e331a7f2124341c"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:e06ed3eb3218bc64786f7db41917d4e686cc4856944f53d5bdf83a6884432e12"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:2e81c7b9c8979ce92ed306c249d46894776a909505d8f5a4ba55b14206e3222f"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:572c3763a264ba47b3cf708a44ce965d98555f618ca42c926a9c1616d8f34269"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:fd1abc0d89e30cc4e02e4064dc67fcc51bd941eb395c502aac3ec19fab46b519"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-win32.whl", hash = "sha256:3d47fa203a7bd9c5b6cee4736ee84ca03b8ef23193c0d1ca99b5089f72645c73"},
-    {file = "charset_normalizer-3.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:10955842570876604d404661fbccbc9c7e684caf432c09c715ec38fbae45ae09"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:802fe99cca7457642125a8a88a084cef28ff0cf9407060f7b93dca5aa25480db"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:573f6eac48f4769d667c4442081b1794f52919e7edada77495aaed9236d13a96"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:549a3a73da901d5bc3ce8d24e0600d1fa85524c10287f6004fbab87672bf3e1e"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f27273b60488abe721a075bcca6d7f3964f9f6f067c8c4c605743023d7d3944f"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1ceae2f17a9c33cb48e3263960dc5fc8005351ee19db217e9b1bb15d28c02574"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:65f6f63034100ead094b8744b3b97965785388f308a64cf8d7c34f2f2e5be0c4"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:753f10e867343b4511128c6ed8c82f7bec3bd026875576dfd88483c5c73b2fd8"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4a78b2b446bd7c934f5dcedc588903fb2f5eec172f3d29e52a9096a43722adfc"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:e537484df0d8f426ce2afb2d0f8e1c3d0b114b83f8850e5f2fbea0e797bd82ae"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:eb6904c354526e758fda7167b33005998fb68c46fbc10e013ca97f21ca5c8887"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:deb6be0ac38ece9ba87dea880e438f25ca3eddfac8b002a2ec3d9183a454e8ae"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:4ab2fe47fae9e0f9dee8c04187ce5d09f48eabe611be8259444906793ab7cbce"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:80402cd6ee291dcb72644d6eac93785fe2c8b9cb30893c1af5b8fdd753b9d40f"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-win32.whl", hash = "sha256:7cd13a2e3ddeed6913a65e66e94b51d80a041145a026c27e6bb76c31a853c6ab"},
-    {file = "charset_normalizer-3.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:663946639d296df6a2bb2aa51b60a2454ca1cb29835324c640dafb5ff2131a77"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:0b2b64d2bb6d3fb9112bafa732def486049e63de9618b5843bcdd081d8144cd8"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:ddbb2551d7e0102e7252db79ba445cdab71b26640817ab1e3e3648dad515003b"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:55086ee1064215781fff39a1af09518bc9255b50d6333f2e4c74ca09fac6a8f6"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8f4a014bc36d3c57402e2977dada34f9c12300af536839dc38c0beab8878f38a"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a10af20b82360ab00827f916a6058451b723b4e65030c5a18577c8b2de5b3389"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d756e44e94489e49571086ef83b2bb8ce311e730092d2c34ca8f7d925cb20aa"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:90d558489962fd4918143277a773316e56c72da56ec7aa3dc3dbbe20fdfed15b"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ac7ffc7ad6d040517be39eb591cac5ff87416c2537df6ba3cba3bae290c0fed"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7ed9e526742851e8d5cc9e6cf41427dfc6068d4f5a3bb03659444b4cabf6bc26"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:8bdb58ff7ba23002a4c5808d608e4e6c687175724f54a5dade5fa8c67b604e4d"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:6b3251890fff30ee142c44144871185dbe13b11bab478a88887a639655be1068"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:b4a23f61ce87adf89be746c8a8974fe1c823c891d8f86eb218bb957c924bb143"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:efcb3f6676480691518c177e3b465bcddf57cea040302f9f4e6e191af91174d4"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-win32.whl", hash = "sha256:d965bba47ddeec8cd560687584e88cf699fd28f192ceb452d1d7ee807c5597b7"},
-    {file = "charset_normalizer-3.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:96b02a3dc4381e5494fad39be677abcb5e6634bf7b4fa83a6dd3112607547001"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:95f2a5796329323b8f0512e09dbb7a1860c46a39da62ecb2324f116fa8fdc85c"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c002b4ffc0be611f0d9da932eb0f704fe2602a9a949d1f738e4c34c75b0863d5"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a981a536974bbc7a512cf44ed14938cf01030a99e9b3a06dd59578882f06f985"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3287761bc4ee9e33561a7e058c72ac0938c4f57fe49a09eae428fd88aafe7bb6"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42cb296636fcc8b0644486d15c12376cb9fa75443e00fb25de0b8602e64c1714"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0a55554a2fa0d408816b3b5cedf0045f4b8e1a6065aec45849de2d6f3f8e9786"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:c083af607d2515612056a31f0a8d9e0fcb5876b7bfc0abad3ecd275bc4ebc2d5"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:87d1351268731db79e0f8e745d92493ee2841c974128ef629dc518b937d9194c"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:bd8f7df7d12c2db9fab40bdd87a7c09b1530128315d047a086fa3ae3435cb3a8"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:c180f51afb394e165eafe4ac2936a14bee3eb10debc9d9e4db8958fe36afe711"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:8c622a5fe39a48f78944a87d4fb8a53ee07344641b0562c540d840748571b811"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-win32.whl", hash = "sha256:db364eca23f876da6f9e16c9da0df51aa4f104a972735574842618b8c6d999d4"},
-    {file = "charset_normalizer-3.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:86216b5cee4b06df986d214f664305142d9c76df9b6512be2738aa72a2048f99"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:6463effa3186ea09411d50efc7d85360b38d5f09b870c48e4600f63af490e56a"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6c4caeef8fa63d06bd437cd4bdcf3ffefe6738fb1b25951440d80dc7df8c03ac"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:37e55c8e51c236f95b033f6fb391d7d7970ba5fe7ff453dad675e88cf303377a"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb69256e180cb6c8a894fee62b3afebae785babc1ee98b81cdf68bbca1987f33"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ae5f4161f18c61806f411a13b0310bea87f987c7d2ecdbdaad0e94eb2e404238"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b2b0a0c0517616b6869869f8c581d4eb2dd83a4d79e0ebcb7d373ef9956aeb0a"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:45485e01ff4d3630ec0d9617310448a8702f70e9c01906b0d0118bdf9d124cf2"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb00ed941194665c332bf8e078baf037d6c35d7c4f3102ea2d4f16ca94a26dc8"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:2127566c664442652f024c837091890cb1942c30937add288223dc895793f898"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:a50aebfa173e157099939b17f18600f72f84eed3049e743b68ad15bd69b6bf99"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:4d0d1650369165a14e14e1e47b372cfcb31d6ab44e6e33cb2d4e57265290044d"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:923c0c831b7cfcb071580d3f46c4baf50f174be571576556269530f4bbd79d04"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:06a81e93cd441c56a9b65d8e1d043daeb97a3d0856d177d5c90ba85acb3db087"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-win32.whl", hash = "sha256:6ef1d82a3af9d3eecdba2321dc1b3c238245d890843e040e41e470ffa64c3e25"},
-    {file = "charset_normalizer-3.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:eb8821e09e916165e160797a6c17edda0679379a4be5c716c260e836e122f54b"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c235ebd9baae02f1b77bcea61bce332cb4331dc3617d254df3323aa01ab47bd4"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5b4c145409bef602a690e7cfad0a15a55c13320ff7a3ad7ca59c13bb8ba4d45d"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:68d1f8a9e9e37c1223b656399be5d6b448dea850bed7d0f87a8311f1ff3dabb0"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22afcb9f253dac0696b5a4be4a1c0f8762f8239e21b99680099abd9b2b1b2269"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e27ad930a842b4c5eb8ac0016b0a54f5aebbe679340c26101df33424142c143c"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1f79682fbe303db92bc2b1136016a38a42e835d932bab5b3b1bfcfbf0640e519"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b261ccdec7821281dade748d088bb6e9b69e6d15b30652b74cbbac25e280b796"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:122c7fa62b130ed55f8f285bfd56d5f4b4a5b503609d181f9ad85e55c89f4185"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:d0eccceffcb53201b5bfebb52600a5fb483a20b61da9dbc885f8b103cbe7598c"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:9f96df6923e21816da7e0ad3fd47dd8f94b2a5ce594e00677c0013018b813458"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:7f04c839ed0b6b98b1a7501a002144b76c18fb1c1850c8b98d458ac269e26ed2"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:34d1c8da1e78d2e001f363791c98a272bb734000fcef47a491c1e3b0505657a8"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:ff8fa367d09b717b2a17a052544193ad76cd49979c805768879cb63d9ca50561"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-win32.whl", hash = "sha256:aed38f6e4fb3f5d6bf81bfa990a07806be9d83cf7bacef998ab1a9bd660a581f"},
-    {file = "charset_normalizer-3.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:b01b88d45a6fcb69667cd6d2f7a9aeb4bf53760d7fc536bf679ec94fe9f3ff3d"},
-    {file = "charset_normalizer-3.3.2-py3-none-any.whl", hash = "sha256:3e4d1f6587322d2788836a99c69062fbb091331ec940e02d12d179c1d53e25fc"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:91b36a978b5ae0ee86c394f5a54d6ef44db1de0815eb43de826d41d21e4af3de"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7461baadb4dc00fd9e0acbe254e3d7d2112e7f92ced2adc96e54ef6501c5f176"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e218488cd232553829be0664c2292d3af2eeeb94b32bea483cf79ac6a694e037"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:80ed5e856eb7f30115aaf94e4a08114ccc8813e6ed1b5efa74f9f82e8509858f"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b010a7a4fd316c3c484d482922d13044979e78d1861f0e0650423144c616a46a"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4532bff1b8421fd0a320463030c7520f56a79c9024a4e88f01c537316019005a"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d973f03c0cb71c5ed99037b870f2be986c3c05e63622c017ea9816881d2dd247"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:3a3bd0dcd373514dcec91c411ddb9632c0d7d92aed7093b8c3bbb6d69ca74408"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:d9c3cdf5390dcd29aa8056d13e8e99526cda0305acc038b96b30352aff5ff2bb"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2bdfe3ac2e1bbe5b59a1a63721eb3b95fc9b6817ae4a46debbb4e11f6232428d"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:eab677309cdb30d047996b36d34caeda1dc91149e4fdca0b1a039b3f79d9a807"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-win32.whl", hash = "sha256:c0429126cf75e16c4f0ad00ee0eae4242dc652290f940152ca8c75c3a4b6ee8f"},
+    {file = "charset_normalizer-3.4.1-cp310-cp310-win_amd64.whl", hash = "sha256:9f0b8b1c6d84c8034a44893aba5e767bf9c7a211e313a9605d9c617d7083829f"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8bfa33f4f2672964266e940dd22a195989ba31669bd84629f05fab3ef4e2d125"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:28bf57629c75e810b6ae989f03c0828d64d6b26a5e205535585f96093e405ed1"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f08ff5e948271dc7e18a35641d2f11a4cd8dfd5634f55228b691e62b37125eb3"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:234ac59ea147c59ee4da87a0c0f098e9c8d169f4dc2a159ef720f1a61bbe27cd"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd4ec41f914fa74ad1b8304bbc634b3de73d2a0889bd32076342a573e0779e00"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eea6ee1db730b3483adf394ea72f808b6e18cf3cb6454b4d86e04fa8c4327a12"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c96836c97b1238e9c9e3fe90844c947d5afbf4f4c92762679acfe19927d81d77"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4d86f7aff21ee58f26dcf5ae81a9addbd914115cdebcbb2217e4f0ed8982e146"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:09b5e6733cbd160dcc09589227187e242a30a49ca5cefa5a7edd3f9d19ed53fd"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:5777ee0881f9499ed0f71cc82cf873d9a0ca8af166dfa0af8ec4e675b7df48e6"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:237bdbe6159cff53b4f24f397d43c6336c6b0b42affbe857970cefbb620911c8"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-win32.whl", hash = "sha256:8417cb1f36cc0bc7eaba8ccb0e04d55f0ee52df06df3ad55259b9a323555fc8b"},
+    {file = "charset_normalizer-3.4.1-cp311-cp311-win_amd64.whl", hash = "sha256:d7f50a1f8c450f3925cb367d011448c39239bb3eb4117c36a6d354794de4ce76"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:73d94b58ec7fecbc7366247d3b0b10a21681004153238750bb67bd9012414545"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dad3e487649f498dd991eeb901125411559b22e8d7ab25d3aeb1af367df5efd7"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c30197aa96e8eed02200a83fba2657b4c3acd0f0aa4bdc9f6c1af8e8962e0757"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2369eea1ee4a7610a860d88f268eb39b95cb588acd7235e02fd5a5601773d4fa"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc2722592d8998c870fa4e290c2eec2c1569b87fe58618e67d38b4665dfa680d"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ffc9202a29ab3920fa812879e95a9e78b2465fd10be7fcbd042899695d75e616"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:804a4d582ba6e5b747c625bf1255e6b1507465494a40a2130978bda7b932c90b"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:0f55e69f030f7163dffe9fd0752b32f070566451afe180f99dbeeb81f511ad8d"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:c4c3e6da02df6fa1410a7680bd3f63d4f710232d3139089536310d027950696a"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:5df196eb874dae23dcfb968c83d4f8fdccb333330fe1fc278ac5ceeb101003a9"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e358e64305fe12299a08e08978f51fc21fac060dcfcddd95453eabe5b93ed0e1"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-win32.whl", hash = "sha256:9b23ca7ef998bc739bf6ffc077c2116917eabcc901f88da1b9856b210ef63f35"},
+    {file = "charset_normalizer-3.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ff8a4a60c227ad87030d76e99cd1698345d4491638dfa6673027c48b3cd395f"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:aabfa34badd18f1da5ec1bc2715cadc8dca465868a4e73a0173466b688f29dda"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22e14b5d70560b8dd51ec22863f370d1e595ac3d024cb8ad7d308b4cd95f8313"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8436c508b408b82d87dc5f62496973a1805cd46727c34440b0d29d8a2f50a6c9"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2d074908e1aecee37a7635990b2c6d504cd4766c7bc9fc86d63f9c09af3fa11b"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:955f8851919303c92343d2f66165294848d57e9bba6cf6e3625485a70a038d11"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:44ecbf16649486d4aebafeaa7ec4c9fed8b88101f4dd612dcaf65d5e815f837f"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:0924e81d3d5e70f8126529951dac65c1010cdf117bb75eb02dd12339b57749dd"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2967f74ad52c3b98de4c3b32e1a44e32975e008a9cd2a8cc8966d6a5218c5cb2"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c75cb2a3e389853835e84a2d8fb2b81a10645b503eca9bcb98df6b5a43eb8886"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:09b26ae6b1abf0d27570633b2b078a2a20419c99d66fb2823173d73f188ce601"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fa88b843d6e211393a37219e6a1c1df99d35e8fd90446f1118f4216e307e48cd"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-win32.whl", hash = "sha256:eb8178fe3dba6450a3e024e95ac49ed3400e506fd4e9e5c32d30adda88cbd407"},
+    {file = "charset_normalizer-3.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:b1ac5992a838106edb89654e0aebfc24f5848ae2547d22c2c3f66454daa11971"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f30bf9fd9be89ecb2360c7d94a711f00c09b976258846efe40db3d05828e8089"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:97f68b8d6831127e4787ad15e6757232e14e12060bec17091b85eb1486b91d8d"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7974a0b5ecd505609e3b19742b60cee7aa2aa2fb3151bc917e6e2646d7667dcf"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fc54db6c8593ef7d4b2a331b58653356cf04f67c960f584edb7c3d8c97e8f39e"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:311f30128d7d333eebd7896965bfcfbd0065f1716ec92bd5638d7748eb6f936a"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:7d053096f67cd1241601111b698f5cad775f97ab25d81567d3f59219b5f1adbd"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:807f52c1f798eef6cf26beb819eeb8819b1622ddfeef9d0977a8502d4db6d534"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:dccbe65bd2f7f7ec22c4ff99ed56faa1e9f785482b9bbd7c717e26fd723a1d1e"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:2fb9bd477fdea8684f78791a6de97a953c51831ee2981f8e4f583ff3b9d9687e"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:01732659ba9b5b873fc117534143e4feefecf3b2078b0a6a2e925271bb6f4cfa"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-win32.whl", hash = "sha256:7a4f97a081603d2050bfaffdefa5b02a9ec823f8348a572e39032caa8404a487"},
+    {file = "charset_normalizer-3.4.1-cp37-cp37m-win_amd64.whl", hash = "sha256:7b1bef6280950ee6c177b326508f86cad7ad4dff12454483b51d8b7d673a2c5d"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ecddf25bee22fe4fe3737a399d0d177d72bc22be6913acfab364b40bce1ba83c"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c60ca7339acd497a55b0ea5d506b2a2612afb2826560416f6894e8b5770d4a9"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b7b2d86dd06bfc2ade3312a83a5c364c7ec2e3498f8734282c6c3d4b07b346b8"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd78cfcda14a1ef52584dbb008f7ac81c1328c0f58184bf9a84c49c605002da6"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6e27f48bcd0957c6d4cb9d6fa6b61d192d0b13d5ef563e5f2ae35feafc0d179c"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01ad647cdd609225c5350561d084b42ddf732f4eeefe6e678765636791e78b9a"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:619a609aa74ae43d90ed2e89bdd784765de0a25ca761b93e196d938b8fd1dbbd"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:89149166622f4db9b4b6a449256291dc87a99ee53151c74cbd82a53c8c2f6ccd"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:7709f51f5f7c853f0fb938bcd3bc59cdfdc5203635ffd18bf354f6967ea0f824"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:345b0426edd4e18138d6528aed636de7a9ed169b4aaf9d61a8c19e39d26838ca"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0907f11d019260cdc3f94fbdb23ff9125f6b5d1039b76003b5b0ac9d6a6c9d5b"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-win32.whl", hash = "sha256:ea0d8d539afa5eb2728aa1932a988a9a7af94f18582ffae4bc10b3fbdad0626e"},
+    {file = "charset_normalizer-3.4.1-cp38-cp38-win_amd64.whl", hash = "sha256:329ce159e82018d646c7ac45b01a430369d526569ec08516081727a20e9e4af4"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:b97e690a2118911e39b4042088092771b4ae3fc3aa86518f84b8cf6888dbdb41"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78baa6d91634dfb69ec52a463534bc0df05dbd546209b79a3880a34487f4b84f"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1a2bc9f351a75ef49d664206d51f8e5ede9da246602dc2d2726837620ea034b2"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75832c08354f595c760a804588b9357d34ec00ba1c940c15e31e96d902093770"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0af291f4fe114be0280cdd29d533696a77b5b49cfde5467176ecab32353395c4"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0167ddc8ab6508fe81860a57dd472b2ef4060e8d378f0cc555707126830f2537"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:2a75d49014d118e4198bcee5ee0a6f25856b29b12dbf7cd012791f8a6cc5c496"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363e2f92b0f0174b2f8238240a1a30142e3db7b957a5dd5689b0e75fb717cc78"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ab36c8eb7e454e34e60eb55ca5d241a5d18b2c6244f6827a30e451c42410b5f7"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:4c0907b1928a36d5a998d72d64d8eaa7244989f7aaaf947500d3a800c83a3fd6"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:04432ad9479fa40ec0f387795ddad4437a2b50417c69fa275e212933519ff294"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-win32.whl", hash = "sha256:3bed14e9c89dcb10e8f3a29f9ccac4955aebe93c71ae803af79265c9ca5644c5"},
+    {file = "charset_normalizer-3.4.1-cp39-cp39-win_amd64.whl", hash = "sha256:49402233c892a461407c512a19435d1ce275543138294f7ef013f0b63d5d3765"},
+    {file = "charset_normalizer-3.4.1-py3-none-any.whl", hash = "sha256:d98b1668f06378c6dbefec3b92299716b931cd4e6061f3c875a71ced1780ab85"},
+    {file = "charset_normalizer-3.4.1.tar.gz", hash = "sha256:44251f18cd68a75b56585dd00dae26183e102cd5e0f9f1466e6df5da2ed64ea3"},
 ]
 
+[[package]]
+name = "clique"
+version = "2.0.0"
+description = "Manage collections with common numerical component"
+optional = false
+python-versions = ">=3.0, <4.0"
+groups = ["dev"]
+files = [
+    {file = "clique-2.0.0-py2.py3-none-any.whl", hash = "sha256:45e2a4c6078382e0b217e5e369494279cf03846d95ee601f93290bed5214c22e"},
+    {file = "clique-2.0.0.tar.gz", hash = "sha256:6e1115dbf21b1726f4b3db9e9567a662d6bdf72487c4a0a1f8cb7f10cf4f4754"},
+]
+
+[package.extras]
+dev = ["lowdown (>=0.2.0,<1)", "pytest (>=2.3.5,<5)", "pytest-cov (>=2,<3)", "pytest-runner (>=2.7,<3)", "sphinx (>=2,<4)", "sphinx-rtd-theme (>=0.1.6,<1)"]
+doc = ["lowdown (>=0.2.0,<1)", "sphinx (>=2,<4)", "sphinx-rtd-theme (>=0.1.6,<1)"]
+test = ["pytest (>=2.3.5,<5)", "pytest-cov (>=2,<3)", "pytest-runner (>=2.7,<3)"]
+
 [[package]]
 name = "codespell"
-version = "2.2.6"
-description = "Codespell"
+version = "2.4.1"
+description = "Fix common misspellings in text files"
 optional = false
 python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "codespell-2.2.6-py3-none-any.whl", hash = "sha256:9ee9a3e5df0990604013ac2a9f22fa8e57669c827124a2e961fe8a1da4cacc07"},
-    {file = "codespell-2.2.6.tar.gz", hash = "sha256:a8c65d8eb3faa03deabab6b3bbe798bea72e1799c7e9e955d57eca4096abcff9"},
+    {file = "codespell-2.4.1-py3-none-any.whl", hash = "sha256:3dadafa67df7e4a3dbf51e0d7315061b80d265f9552ebd699b3dd6834b47e425"},
+    {file = "codespell-2.4.1.tar.gz", hash = "sha256:299fcdcb09d23e81e35a671bbe746d5ad7e8385972e65dbb833a2eaac33c01e5"},
 ]
 
 [package.extras]
 dev = ["Pygments", "build", "chardet", "pre-commit", "pytest", "pytest-cov", "pytest-dependency", "ruff", "tomli", "twine"]
 hard-encoding-detection = ["chardet"]
-toml = ["tomli"]
+toml = ["tomli ; python_version < \"3.11\""]
 types = ["chardet (>=5.1.0)", "mypy", "pytest", "pytest-cov", "pytest-dependency"]
 
 [[package]]
@@ -172,6 +216,8 @@ version = "0.4.6"
 description = "Cross-platform colored terminal text."
 optional = false
 python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+groups = ["dev"]
+markers = "sys_platform == \"win32\""
 files = [
     {file = "colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6"},
     {file = "colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44"},
@@ -179,24 +225,26 @@ files = [
 
 [[package]]
 name = "distlib"
-version = "0.3.8"
+version = "0.3.9"
 description = "Distribution utilities"
 optional = false
 python-versions = "*"
+groups = ["dev"]
 files = [
-    {file = "distlib-0.3.8-py2.py3-none-any.whl", hash = "sha256:034db59a0b96f8ca18035f36290806a9a6e6bd9d1ff91e45a7f172eb17e51784"},
-    {file = "distlib-0.3.8.tar.gz", hash = "sha256:1530ea13e350031b6312d8580ddb6b27a104275a31106523b8f123787f494f64"},
+    {file = "distlib-0.3.9-py2.py3-none-any.whl", hash = "sha256:47f8c22fd27c27e25a65601af709b38e4f0a45ea4fc2e710f65755fa8caaaf87"},
+    {file = "distlib-0.3.9.tar.gz", hash = "sha256:a60f20dea646b8a33f3e7772f74dc0b2d0772d2837ee1342a00645c81edf9403"},
 ]
 
 [[package]]
 name = "exceptiongroup"
-version = "1.2.0"
+version = "1.2.2"
 description = "Backport of PEP 654 (exception groups)"
 optional = false
 python-versions = ">=3.7"
+groups = ["dev"]
 files = [
-    {file = "exceptiongroup-1.2.0-py3-none-any.whl", hash = "sha256:4bfd3996ac73b41e9b9628b04e079f193850720ea5945fc96a08633c66912f14"},
-    {file = "exceptiongroup-1.2.0.tar.gz", hash = "sha256:91f5c769735f051a4290d52edd0858999b57e5876e9f85937691bd4c9fa3ed68"},
+    {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"},
+    {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"},
 ]
 
 [package.extras]
@@ -204,29 +252,31 @@ test = ["pytest (>=6)"]
 
 [[package]]
 name = "filelock"
-version = "3.13.1"
+version = "3.17.0"
 description = "A platform independent file lock."
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
+groups = ["dev"]
 files = [
-    {file = "filelock-3.13.1-py3-none-any.whl", hash = "sha256:57dbda9b35157b05fb3e58ee91448612eb674172fab98ee235ccb0b5bee19a1c"},
-    {file = "filelock-3.13.1.tar.gz", hash = "sha256:521f5f56c50f8426f5e03ad3b281b490a87ef15bc6c526f168290f0c7148d44e"},
+    {file = "filelock-3.17.0-py3-none-any.whl", hash = "sha256:533dc2f7ba78dc2f0f531fc6c4940addf7b70a481e269a5a3b93be94ffbe8338"},
+    {file = "filelock-3.17.0.tar.gz", hash = "sha256:ee4e77401ef576ebb38cd7f13b9b28893194acc20a8e68e18730ba9c0e54660e"},
 ]
 
 [package.extras]
-docs = ["furo (>=2023.9.10)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.24)"]
-testing = ["covdefaults (>=2.3)", "coverage (>=7.3.2)", "diff-cover (>=8)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)", "pytest-timeout (>=2.2)"]
-typing = ["typing-extensions (>=4.8)"]
+docs = ["furo (>=2024.8.6)", "sphinx (>=8.1.3)", "sphinx-autodoc-typehints (>=3)"]
+testing = ["covdefaults (>=2.3)", "coverage (>=7.6.10)", "diff-cover (>=9.2.1)", "pytest (>=8.3.4)", "pytest-asyncio (>=0.25.2)", "pytest-cov (>=6)", "pytest-mock (>=3.14)", "pytest-timeout (>=2.3.1)", "virtualenv (>=20.28.1)"]
+typing = ["typing-extensions (>=4.12.2) ; python_version < \"3.11\""]
 
 [[package]]
 name = "identify"
-version = "2.5.35"
+version = "2.6.7"
 description = "File identification library for Python"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
+groups = ["dev"]
 files = [
-    {file = "identify-2.5.35-py2.py3-none-any.whl", hash = "sha256:c4de0081837b211594f8e877a6b4fad7ca32bbfc1a9307fdd61c28bfe923f13e"},
-    {file = "identify-2.5.35.tar.gz", hash = "sha256:10a7ca245cfcd756a554a7288159f72ff105ad233c7c4b9c6f0f4d108f5f6791"},
+    {file = "identify-2.6.7-py2.py3-none-any.whl", hash = "sha256:155931cb617a401807b09ecec6635d6c692d180090a1cedca8ef7d58ba5b6aa0"},
+    {file = "identify-2.6.7.tar.gz", hash = "sha256:3fa266b42eba321ee0b2bb0936a6a6b9e36a1351cbb69055b3082f4193035684"},
 ]
 
 [package.extras]
@@ -234,75 +284,149 @@ license = ["ukkonen"]
 
 [[package]]
 name = "idna"
-version = "3.6"
+version = "3.10"
 description = "Internationalized Domain Names in Applications (IDNA)"
 optional = false
-python-versions = ">=3.5"
+python-versions = ">=3.6"
+groups = ["dev"]
 files = [
-    {file = "idna-3.6-py3-none-any.whl", hash = "sha256:c05567e9c24a6b9faaa835c4821bad0590fbb9d5779e7caa6e1cc4978e7eb24f"},
-    {file = "idna-3.6.tar.gz", hash = "sha256:9ecdbbd083b06798ae1e86adcbfe8ab1479cf864e4ee30fe4e46a003d12491ca"},
+    {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"},
+    {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"},
 ]
 
+[package.extras]
+all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"]
+
 [[package]]
 name = "iniconfig"
 version = "2.0.0"
 description = "brain-dead simple config-ini parsing"
 optional = false
 python-versions = ">=3.7"
+groups = ["dev"]
 files = [
     {file = "iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374"},
     {file = "iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3"},
 ]
 
 [[package]]
-name = "nodeenv"
-version = "1.8.0"
-description = "Node.js virtual environment builder"
+name = "mock"
+version = "5.1.0"
+description = "Rolling backport of unittest.mock for all Pythons"
 optional = false
-python-versions = ">=2.7,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*"
+python-versions = ">=3.6"
+groups = ["dev"]
 files = [
-    {file = "nodeenv-1.8.0-py2.py3-none-any.whl", hash = "sha256:df865724bb3c3adc86b3876fa209771517b0cfe596beff01a92700e0e8be4cec"},
-    {file = "nodeenv-1.8.0.tar.gz", hash = "sha256:d51e0c37e64fbf47d017feac3145cdbb58836d7eee8c6f6d3b6880c5456227d2"},
+    {file = "mock-5.1.0-py3-none-any.whl", hash = "sha256:18c694e5ae8a208cdb3d2c20a993ca1a7b0efa258c247a1e565150f477f83744"},
+    {file = "mock-5.1.0.tar.gz", hash = "sha256:5e96aad5ccda4718e0a229ed94b2024df75cc2d55575ba5762d31f5767b8767d"},
 ]
 
-[package.dependencies]
-setuptools = "*"
+[package.extras]
+build = ["blurb", "twine", "wheel"]
+docs = ["sphinx"]
+test = ["pytest", "pytest-cov"]
+
+[[package]]
+name = "nodeenv"
+version = "1.9.1"
+description = "Node.js virtual environment builder"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7"
+groups = ["dev"]
+files = [
+    {file = "nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9"},
+    {file = "nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f"},
+]
+
+[[package]]
+name = "opentimelineio"
+version = "0.17.0"
+description = "Editorial interchange format and API"
+optional = false
+python-versions = "!=3.9.0,>=3.7"
+groups = ["dev"]
+files = [
+    {file = "OpenTimelineIO-0.17.0-cp310-cp310-macosx_10_14_x86_64.whl", hash = "sha256:2dd31a570cabfd6227c1b1dd0cc038da10787492c26c55de058326e21fe8a313"},
+    {file = "OpenTimelineIO-0.17.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5a1da5d4803d1ba5e846b181a9e0f4a392c76b9acc5e08947772bc086f2ebfc0"},
+    {file = "OpenTimelineIO-0.17.0-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3527977aec8202789a42d60e1e0dc11b4154f585ef72921760445f43e7967a00"},
+    {file = "OpenTimelineIO-0.17.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b3aafb4c50455832ed2627c2cac654b896473a5c1f8348ddc07c10be5cfbd59"},
+    {file = "OpenTimelineIO-0.17.0-cp310-cp310-win32.whl", hash = "sha256:fee45af9f6330773893cd0858e92f8256bb5bde4229b44a76f03e59a9fb1b1b6"},
+    {file = "OpenTimelineIO-0.17.0-cp310-cp310-win_amd64.whl", hash = "sha256:d51887619689c21d67cc4b11b1088f99ae44094513315e7a144be00f1393bfa8"},
+    {file = "OpenTimelineIO-0.17.0-cp311-cp311-macosx_10_14_x86_64.whl", hash = "sha256:cbf05c3e8c0187969f79e91f7495d1f0dc3609557874d8e601ba2e072c70ddb1"},
+    {file = "OpenTimelineIO-0.17.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d3430c3f4e88c5365d7b6afbee920b0815b62ecf141abe44cd739c9eedc04284"},
+    {file = "OpenTimelineIO-0.17.0-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b1912345227b0bd1654c7153863eadbcee60362aa46340678e576e5d2aa3106a"},
+    {file = "OpenTimelineIO-0.17.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:51e06eb11a868d970c1534e39faf916228d5163bf3598076d408d8f393ab0bd4"},
+    {file = "OpenTimelineIO-0.17.0-cp311-cp311-win32.whl", hash = "sha256:5c3a3f4780b25a8c1a80d788becba691d12b629069ad8783d0db21027639276f"},
+    {file = "OpenTimelineIO-0.17.0-cp311-cp311-win_amd64.whl", hash = "sha256:43c8726b33af30ba42928972192311ea0f986edbbd5f74651bada182d4fe805c"},
+    {file = "OpenTimelineIO-0.17.0-cp312-cp312-macosx_10_14_x86_64.whl", hash = "sha256:9a9af4105a088c0ab131780e49db268db7e37871aac33db842de6b2b16f14e39"},
+    {file = "OpenTimelineIO-0.17.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8e653ad1dd3b85f5c312a742dc24b61b330964aa391dc5bc072fe8b9c85adff1"},
+    {file = "OpenTimelineIO-0.17.0-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02a77823c27a1b93c6b87682372c3734ac5fddc10bfe53875e657d43c60fb885"},
+    {file = "OpenTimelineIO-0.17.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a4f4efcf3ddd81b62c4feb49a0bcc309b50ffeb6a8c48ab173d169a029006f4d"},
+    {file = "OpenTimelineIO-0.17.0-cp312-cp312-win32.whl", hash = "sha256:9872ab74a20bb2bb3a50af04e80fe9238998d67d6be4e30e45aebe25d3eefac6"},
+    {file = "OpenTimelineIO-0.17.0-cp312-cp312-win_amd64.whl", hash = "sha256:c83b78be3312d3152d7e07ab32b0086fe220acc2a5b035b70ad69a787c0ece62"},
+    {file = "OpenTimelineIO-0.17.0-cp37-cp37m-macosx_10_14_x86_64.whl", hash = "sha256:0e671a6f2a1f772445bb326c7640dc977cfc3db589fe108a783a0311939cfac8"},
+    {file = "OpenTimelineIO-0.17.0-cp37-cp37m-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b931a3189b4ce064f06f15a89fe08ef4de01f7dcf0abc441fe2e02ef2a3311bb"},
+    {file = "OpenTimelineIO-0.17.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:923cb54d806c981cf1e91916c3e57fba5664c22f37763dd012bad5a5a7bd4db4"},
+    {file = "OpenTimelineIO-0.17.0-cp37-cp37m-win32.whl", hash = "sha256:8e16598c5084dcb21df3d83978b0e5f72300af9edd4cdcb85e3b0ba5da0df4e8"},
+    {file = "OpenTimelineIO-0.17.0-cp37-cp37m-win_amd64.whl", hash = "sha256:7eed5033494888fb3f802af50e60559e279b2f398802748872903c2f54efd2c9"},
+    {file = "OpenTimelineIO-0.17.0-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:118baa22b9227da5003bee653601a68686ae2823682dcd7d13c88178c63081c3"},
+    {file = "OpenTimelineIO-0.17.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:43389eacdee2169de454e1c79ecfea82f54a9e73b67151427a9b621349a22b7f"},
+    {file = "OpenTimelineIO-0.17.0-cp38-cp38-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:17659b1e6aa42ed617a942f7a2bfc6ecc375d0464ec127ce9edf896278ecaee9"},
+    {file = "OpenTimelineIO-0.17.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36d5ea8cfbebf3c9013cc680eef5be48bffb515aafa9dc31e99bf66052a4ca3d"},
+    {file = "OpenTimelineIO-0.17.0-cp38-cp38-win32.whl", hash = "sha256:cc67c74eb4b73bc0f7d135d3ff3dbbd86b2d451a9b142690a8d1631ad79c46f2"},
+    {file = "OpenTimelineIO-0.17.0-cp38-cp38-win_amd64.whl", hash = "sha256:69b39079bee6fa4aff34c6ad6544df394bc7388483fa5ce958ecd16e243a53ad"},
+    {file = "OpenTimelineIO-0.17.0-cp39-cp39-macosx_10_14_x86_64.whl", hash = "sha256:a33554894dea17c22feec0201991e705c2c90a679ba2a012a0c558a7130df711"},
+    {file = "OpenTimelineIO-0.17.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:6b1ad3b3155370245b851b2f7b60006b2ebbb5bb76dd0fdc49bb4dce73fa7d96"},
+    {file = "OpenTimelineIO-0.17.0-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:030454a9c0e9e82e5a153119f9afb8f3f4e64a3b27f80ac0dcde44b029fd3f3f"},
+    {file = "OpenTimelineIO-0.17.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bce64376a28919533bd4f744ff8885118abefa73f78fd408f95fa7a9489855b6"},
+    {file = "OpenTimelineIO-0.17.0-cp39-cp39-win32.whl", hash = "sha256:fa8cdceb25f9003c3c0b5b32baef2c764949d88b867161ddc6f44f48f6bbfa4a"},
+    {file = "OpenTimelineIO-0.17.0-cp39-cp39-win_amd64.whl", hash = "sha256:fbcf8a000cd688633c8dc5d22e91912013c67c674329eba603358e3b54da32bf"},
+    {file = "opentimelineio-0.17.0.tar.gz", hash = "sha256:10ef324e710457e9977387cd9ef91eb24a9837bfb370aec3330f9c0f146cea85"},
+]
+
+[package.extras]
+dev = ["check-manifest", "coverage (>=4.5)", "flake8 (>=3.5)", "urllib3 (>=1.24.3)"]
+view = ["PySide2 (>=5.11,<6.0) ; platform_machine == \"x86_64\"", "PySide6 (>=6.2,<7.0) ; platform_machine == \"aarch64\""]
 
 [[package]]
 name = "packaging"
-version = "24.0"
+version = "24.2"
 description = "Core utilities for Python packages"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"},
-    {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"},
+    {file = "packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759"},
+    {file = "packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f"},
 ]
 
 [[package]]
 name = "platformdirs"
-version = "4.2.0"
-description = "A small Python package for determining appropriate platform-specific dirs, e.g. a \"user data dir\"."
+version = "4.3.6"
+description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`."
 optional = false
 python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "platformdirs-4.2.0-py3-none-any.whl", hash = "sha256:0614df2a2f37e1a662acbd8e2b25b92ccf8632929bc6d43467e17fe89c75e068"},
-    {file = "platformdirs-4.2.0.tar.gz", hash = "sha256:ef0cc731df711022c174543cb70a9b5bd22e5a9337c8624ef2c2ceb8ddad8768"},
+    {file = "platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb"},
+    {file = "platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907"},
 ]
 
 [package.extras]
-docs = ["furo (>=2023.9.10)", "proselint (>=0.13)", "sphinx (>=7.2.6)", "sphinx-autodoc-typehints (>=1.25.2)"]
-test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=7.4.3)", "pytest-cov (>=4.1)", "pytest-mock (>=3.12)"]
+docs = ["furo (>=2024.8.6)", "proselint (>=0.14)", "sphinx (>=8.0.2)", "sphinx-autodoc-typehints (>=2.4)"]
+test = ["appdirs (==1.4.4)", "covdefaults (>=2.3)", "pytest (>=8.3.2)", "pytest-cov (>=5)", "pytest-mock (>=3.14)"]
+type = ["mypy (>=1.11.2)"]
 
 [[package]]
 name = "pluggy"
-version = "1.4.0"
+version = "1.5.0"
 description = "plugin and hook calling mechanisms for python"
 optional = false
 python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "pluggy-1.4.0-py3-none-any.whl", hash = "sha256:7db9f7b503d67d1c5b95f59773ebb58a8c1c288129a88665838012cfb07b8981"},
-    {file = "pluggy-1.4.0.tar.gz", hash = "sha256:8c85c2876142a764e5b7548e7d9a0e0ddb46f5185161049a79b7e974454223be"},
+    {file = "pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669"},
+    {file = "pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1"},
 ]
 
 [package.extras]
@@ -311,13 +435,14 @@ testing = ["pytest", "pytest-benchmark"]
 
 [[package]]
 name = "pre-commit"
-version = "3.6.2"
+version = "3.8.0"
 description = "A framework for managing and maintaining multi-language pre-commit hooks."
 optional = false
 python-versions = ">=3.9"
+groups = ["dev"]
 files = [
-    {file = "pre_commit-3.6.2-py2.py3-none-any.whl", hash = "sha256:ba637c2d7a670c10daedc059f5c49b5bd0aadbccfcd7ec15592cf9665117532c"},
-    {file = "pre_commit-3.6.2.tar.gz", hash = "sha256:c3ef34f463045c88658c5b99f38c1e297abdcc0ff13f98d3370055fbbfabc67e"},
+    {file = "pre_commit-3.8.0-py2.py3-none-any.whl", hash = "sha256:9a90a53bf82fdd8778d58085faf8d83df56e40dfe18f45b19446e26bf1b3a63f"},
+    {file = "pre_commit-3.8.0.tar.gz", hash = "sha256:8bb6494d4a20423842e198980c9ecf9f96607a07ea29549e180eef9ae80fe7af"},
 ]
 
 [package.dependencies]
@@ -327,15 +452,28 @@ nodeenv = ">=0.11.1"
 pyyaml = ">=5.1"
 virtualenv = ">=20.10.0"
 
+[[package]]
+name = "pyblish-base"
+version = "1.8.12"
+description = "Plug-in driven automation framework for content"
+optional = false
+python-versions = "*"
+groups = ["dev"]
+files = [
+    {file = "pyblish-base-1.8.12.tar.gz", hash = "sha256:ebc184eb038864380555227a8b58055dd24ece7e6ef7f16d33416c718512871b"},
+    {file = "pyblish_base-1.8.12-py2.py3-none-any.whl", hash = "sha256:2cbe956bfbd4175a2d7d22b344cd345800f4d4437153434ab658fc12646a11e8"},
+]
+
 [[package]]
 name = "pytest"
-version = "8.1.1"
+version = "8.3.4"
 description = "pytest: simple powerful testing with Python"
 optional = false
 python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "pytest-8.1.1-py3-none-any.whl", hash = "sha256:2a8386cfc11fa9d2c50ee7b2a57e7d898ef90470a7a34c4b949ff59662bb78b7"},
-    {file = "pytest-8.1.1.tar.gz", hash = "sha256:ac978141a75948948817d360297b7aae0fcb9d6ff6bc9ec6d514b85d5a65c044"},
+    {file = "pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6"},
+    {file = "pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761"},
 ]
 
 [package.dependencies]
@@ -343,97 +481,103 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""}
 exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""}
 iniconfig = "*"
 packaging = "*"
-pluggy = ">=1.4,<2.0"
+pluggy = ">=1.5,<2"
 tomli = {version = ">=1", markers = "python_version < \"3.11\""}
 
 [package.extras]
-testing = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
+dev = ["argcomplete", "attrs (>=19.2)", "hypothesis (>=3.56)", "mock", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
 [[package]]
 name = "pytest-print"
-version = "1.0.0"
+version = "1.0.2"
 description = "pytest-print adds the printer fixture you can use to print messages to the user (directly to the pytest runner, not stdout)"
 optional = false
 python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "pytest_print-1.0.0-py3-none-any.whl", hash = "sha256:23484f42b906b87e31abd564761efffeb0348a6f83109fb857ee6e8e5df42b69"},
-    {file = "pytest_print-1.0.0.tar.gz", hash = "sha256:1fcde9945fba462227a8959271369b10bb7a193be8452162707e63cd60875ca0"},
+    {file = "pytest_print-1.0.2-py3-none-any.whl", hash = "sha256:3ae7891085dddc3cd697bd6956787240107fe76d6b5cdcfcd782e33ca6543de9"},
+    {file = "pytest_print-1.0.2.tar.gz", hash = "sha256:2780350a7bbe7117f99c5d708dc7b0431beceda021b1fd3f11200670d7f33679"},
 ]
 
 [package.dependencies]
-pytest = ">=7.4"
+pytest = ">=8.3.2"
 
 [package.extras]
-test = ["covdefaults (>=2.3)", "coverage (>=7.3)", "pytest-mock (>=3.11.1)"]
+test = ["covdefaults (>=2.3)", "coverage (>=7.6.1)", "pytest-mock (>=3.14)"]
 
 [[package]]
 name = "pyyaml"
-version = "6.0.1"
+version = "6.0.2"
 description = "YAML parser and emitter for Python"
 optional = false
-python-versions = ">=3.6"
+python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "PyYAML-6.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d858aa552c999bc8a8d57426ed01e40bef403cd8ccdd0fc5f6f04a00414cac2a"},
-    {file = "PyYAML-6.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:fd66fc5d0da6d9815ba2cebeb4205f95818ff4b79c3ebe268e75d961704af52f"},
-    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69b023b2b4daa7548bcfbd4aa3da05b3a74b772db9e23b982788168117739938"},
-    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:81e0b275a9ecc9c0c0c07b4b90ba548307583c125f54d5b6946cfee6360c733d"},
-    {file = "PyYAML-6.0.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ba336e390cd8e4d1739f42dfe9bb83a3cc2e80f567d8805e11b46f4a943f5515"},
-    {file = "PyYAML-6.0.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:326c013efe8048858a6d312ddd31d56e468118ad4cdeda36c719bf5bb6192290"},
-    {file = "PyYAML-6.0.1-cp310-cp310-win32.whl", hash = "sha256:bd4af7373a854424dabd882decdc5579653d7868b8fb26dc7d0e99f823aa5924"},
-    {file = "PyYAML-6.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:fd1592b3fdf65fff2ad0004b5e363300ef59ced41c2e6b3a99d4089fa8c5435d"},
-    {file = "PyYAML-6.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6965a7bc3cf88e5a1c3bd2e0b5c22f8d677dc88a455344035f03399034eb3007"},
-    {file = "PyYAML-6.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f003ed9ad21d6a4713f0a9b5a7a0a79e08dd0f221aff4525a2be4c346ee60aab"},
-    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:42f8152b8dbc4fe7d96729ec2b99c7097d656dc1213a3229ca5383f973a5ed6d"},
-    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:062582fca9fabdd2c8b54a3ef1c978d786e0f6b3a1510e0ac93ef59e0ddae2bc"},
-    {file = "PyYAML-6.0.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b04aac4d386b172d5b9692e2d2da8de7bfb6c387fa4f801fbf6fb2e6ba4673"},
-    {file = "PyYAML-6.0.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:e7d73685e87afe9f3b36c799222440d6cf362062f78be1013661b00c5c6f678b"},
-    {file = "PyYAML-6.0.1-cp311-cp311-win32.whl", hash = "sha256:1635fd110e8d85d55237ab316b5b011de701ea0f29d07611174a1b42f1444741"},
-    {file = "PyYAML-6.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:bf07ee2fef7014951eeb99f56f39c9bb4af143d8aa3c21b1677805985307da34"},
-    {file = "PyYAML-6.0.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:855fb52b0dc35af121542a76b9a84f8d1cd886ea97c84703eaa6d88e37a2ad28"},
-    {file = "PyYAML-6.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:40df9b996c2b73138957fe23a16a4f0ba614f4c0efce1e9406a184b6d07fa3a9"},
-    {file = "PyYAML-6.0.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c22bec3fbe2524cde73d7ada88f6566758a8f7227bfbf93a408a9d86bcc12a0"},
-    {file = "PyYAML-6.0.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8d4e9c88387b0f5c7d5f281e55304de64cf7f9c0021a3525bd3b1c542da3b0e4"},
-    {file = "PyYAML-6.0.1-cp312-cp312-win32.whl", hash = "sha256:d483d2cdf104e7c9fa60c544d92981f12ad66a457afae824d146093b8c294c54"},
-    {file = "PyYAML-6.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:0d3304d8c0adc42be59c5f8a4d9e3d7379e6955ad754aa9d6ab7a398b59dd1df"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:50550eb667afee136e9a77d6dc71ae76a44df8b3e51e41b77f6de2932bfe0f47"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fe35611261b29bd1de0070f0b2f47cb6ff71fa6595c077e42bd0c419fa27b98"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:704219a11b772aea0d8ecd7058d0082713c3562b4e271b849ad7dc4a5c90c13c"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:afd7e57eddb1a54f0f1a974bc4391af8bcce0b444685d936840f125cf046d5bd"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-win32.whl", hash = "sha256:fca0e3a251908a499833aa292323f32437106001d436eca0e6e7833256674585"},
-    {file = "PyYAML-6.0.1-cp36-cp36m-win_amd64.whl", hash = "sha256:f22ac1c3cac4dbc50079e965eba2c1058622631e526bd9afd45fedd49ba781fa"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:b1275ad35a5d18c62a7220633c913e1b42d44b46ee12554e5fd39c70a243d6a3"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:18aeb1bf9a78867dc38b259769503436b7c72f7a1f1f4c93ff9a17de54319b27"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:596106435fa6ad000c2991a98fa58eeb8656ef2325d7e158344fb33864ed87e3"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baa90d3f661d43131ca170712d903e6295d1f7a0f595074f151c0aed377c9b9c"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-win32.whl", hash = "sha256:9046c58c4395dff28dd494285c82ba00b546adfc7ef001486fbf0324bc174fba"},
-    {file = "PyYAML-6.0.1-cp37-cp37m-win_amd64.whl", hash = "sha256:4fb147e7a67ef577a588a0e2c17b6db51dda102c71de36f8549b6816a96e1867"},
-    {file = "PyYAML-6.0.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1d4c7e777c441b20e32f52bd377e0c409713e8bb1386e1099c2415f26e479595"},
-    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0cd17c15d3bb3fa06978b4e8958dcdc6e0174ccea823003a106c7d4d7899ac5"},
-    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28c119d996beec18c05208a8bd78cbe4007878c6dd15091efb73a30e90539696"},
-    {file = "PyYAML-6.0.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7e07cbde391ba96ab58e532ff4803f79c4129397514e1413a7dc761ccd755735"},
-    {file = "PyYAML-6.0.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:49a183be227561de579b4a36efbb21b3eab9651dd81b1858589f796549873dd6"},
-    {file = "PyYAML-6.0.1-cp38-cp38-win32.whl", hash = "sha256:184c5108a2aca3c5b3d3bf9395d50893a7ab82a38004c8f61c258d4428e80206"},
-    {file = "PyYAML-6.0.1-cp38-cp38-win_amd64.whl", hash = "sha256:1e2722cc9fbb45d9b87631ac70924c11d3a401b2d7f410cc0e3bbf249f2dca62"},
-    {file = "PyYAML-6.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9eb6caa9a297fc2c2fb8862bc5370d0303ddba53ba97e71f08023b6cd73d16a8"},
-    {file = "PyYAML-6.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:c8098ddcc2a85b61647b2590f825f3db38891662cfc2fc776415143f599bb859"},
-    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5773183b6446b2c99bb77e77595dd486303b4faab2b086e7b17bc6bef28865f6"},
-    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b786eecbdf8499b9ca1d697215862083bd6d2a99965554781d0d8d1ad31e13a0"},
-    {file = "PyYAML-6.0.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc1bf2925a1ecd43da378f4db9e4f799775d6367bdb94671027b73b393a7c42c"},
-    {file = "PyYAML-6.0.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:04ac92ad1925b2cff1db0cfebffb6ffc43457495c9b3c39d3fcae417d7125dc5"},
-    {file = "PyYAML-6.0.1-cp39-cp39-win32.whl", hash = "sha256:faca3bdcf85b2fc05d06ff3fbc1f83e1391b3e724afa3feba7d13eeab355484c"},
-    {file = "PyYAML-6.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:510c9deebc5c0225e8c96813043e62b680ba2f9c50a08d3724c7f28a747d1486"},
-    {file = "PyYAML-6.0.1.tar.gz", hash = "sha256:bfdf460b1736c775f2ba9f6a92bca30bc2095067b8a9d77876d1fad6cc3b4a43"},
+    {file = "PyYAML-6.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:0a9a2848a5b7feac301353437eb7d5957887edbf81d56e903999a75a3d743086"},
+    {file = "PyYAML-6.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:29717114e51c84ddfba879543fb232a6ed60086602313ca38cce623c1d62cfbf"},
+    {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8824b5a04a04a047e72eea5cec3bc266db09e35de6bdfe34c9436ac5ee27d237"},
+    {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c36280e6fb8385e520936c3cb3b8042851904eba0e58d277dca80a5cfed590b"},
+    {file = "PyYAML-6.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ec031d5d2feb36d1d1a24380e4db6d43695f3748343d99434e6f5f9156aaa2ed"},
+    {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:936d68689298c36b53b29f23c6dbb74de12b4ac12ca6cfe0e047bedceea56180"},
+    {file = "PyYAML-6.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:23502f431948090f597378482b4812b0caae32c22213aecf3b55325e049a6c68"},
+    {file = "PyYAML-6.0.2-cp310-cp310-win32.whl", hash = "sha256:2e99c6826ffa974fe6e27cdb5ed0021786b03fc98e5ee3c5bfe1fd5015f42b99"},
+    {file = "PyYAML-6.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:a4d3091415f010369ae4ed1fc6b79def9416358877534caf6a0fdd2146c87a3e"},
+    {file = "PyYAML-6.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:cc1c1159b3d456576af7a3e4d1ba7e6924cb39de8f67111c735f6fc832082774"},
+    {file = "PyYAML-6.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:1e2120ef853f59c7419231f3bf4e7021f1b936f6ebd222406c3b60212205d2ee"},
+    {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d225db5a45f21e78dd9358e58a98702a0302f2659a3c6cd320564b75b86f47c"},
+    {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5ac9328ec4831237bec75defaf839f7d4564be1e6b25ac710bd1a96321cc8317"},
+    {file = "PyYAML-6.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ad2a3decf9aaba3d29c8f537ac4b243e36bef957511b4766cb0057d32b0be85"},
+    {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:ff3824dc5261f50c9b0dfb3be22b4567a6f938ccce4587b38952d85fd9e9afe4"},
+    {file = "PyYAML-6.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:797b4f722ffa07cc8d62053e4cff1486fa6dc094105d13fea7b1de7d8bf71c9e"},
+    {file = "PyYAML-6.0.2-cp311-cp311-win32.whl", hash = "sha256:11d8f3dd2b9c1207dcaf2ee0bbbfd5991f571186ec9cc78427ba5bd32afae4b5"},
+    {file = "PyYAML-6.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:e10ce637b18caea04431ce14fabcf5c64a1c61ec9c56b071a4b7ca131ca52d44"},
+    {file = "PyYAML-6.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:c70c95198c015b85feafc136515252a261a84561b7b1d51e3384e0655ddf25ab"},
+    {file = "PyYAML-6.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:ce826d6ef20b1bc864f0a68340c8b3287705cae2f8b4b1d932177dcc76721725"},
+    {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f71ea527786de97d1a0cc0eacd1defc0985dcf6b3f17bb77dcfc8c34bec4dc5"},
+    {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9b22676e8097e9e22e36d6b7bda33190d0d400f345f23d4065d48f4ca7ae0425"},
+    {file = "PyYAML-6.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80bab7bfc629882493af4aa31a4cfa43a4c57c83813253626916b8c7ada83476"},
+    {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:0833f8694549e586547b576dcfaba4a6b55b9e96098b36cdc7ebefe667dfed48"},
+    {file = "PyYAML-6.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8b9c7197f7cb2738065c481a0461e50ad02f18c78cd75775628afb4d7137fb3b"},
+    {file = "PyYAML-6.0.2-cp312-cp312-win32.whl", hash = "sha256:ef6107725bd54b262d6dedcc2af448a266975032bc85ef0172c5f059da6325b4"},
+    {file = "PyYAML-6.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:7e7401d0de89a9a855c839bc697c079a4af81cf878373abd7dc625847d25cbd8"},
+    {file = "PyYAML-6.0.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:efdca5630322a10774e8e98e1af481aad470dd62c3170801852d752aa7a783ba"},
+    {file = "PyYAML-6.0.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:50187695423ffe49e2deacb8cd10510bc361faac997de9efef88badc3bb9e2d1"},
+    {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ffe8360bab4910ef1b9e87fb812d8bc0a308b0d0eef8c8f44e0254ab3b07133"},
+    {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:17e311b6c678207928d649faa7cb0d7b4c26a0ba73d41e99c4fff6b6c3276484"},
+    {file = "PyYAML-6.0.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:70b189594dbe54f75ab3a1acec5f1e3faa7e8cf2f1e08d9b561cb41b845f69d5"},
+    {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:41e4e3953a79407c794916fa277a82531dd93aad34e29c2a514c2c0c5fe971cc"},
+    {file = "PyYAML-6.0.2-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:68ccc6023a3400877818152ad9a1033e3db8625d899c72eacb5a668902e4d652"},
+    {file = "PyYAML-6.0.2-cp313-cp313-win32.whl", hash = "sha256:bc2fa7c6b47d6bc618dd7fb02ef6fdedb1090ec036abab80d4681424b84c1183"},
+    {file = "PyYAML-6.0.2-cp313-cp313-win_amd64.whl", hash = "sha256:8388ee1976c416731879ac16da0aff3f63b286ffdd57cdeb95f3f2e085687563"},
+    {file = "PyYAML-6.0.2-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:24471b829b3bf607e04e88d79542a9d48bb037c2267d7927a874e6c205ca7e9a"},
+    {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7fded462629cfa4b685c5416b949ebad6cec74af5e2d42905d41e257e0869f5"},
+    {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d84a1718ee396f54f3a086ea0a66d8e552b2ab2017ef8b420e92edbc841c352d"},
+    {file = "PyYAML-6.0.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9056c1ecd25795207ad294bcf39f2db3d845767be0ea6e6a34d856f006006083"},
+    {file = "PyYAML-6.0.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:82d09873e40955485746739bcb8b4586983670466c23382c19cffecbf1fd8706"},
+    {file = "PyYAML-6.0.2-cp38-cp38-win32.whl", hash = "sha256:43fa96a3ca0d6b1812e01ced1044a003533c47f6ee8aca31724f78e93ccc089a"},
+    {file = "PyYAML-6.0.2-cp38-cp38-win_amd64.whl", hash = "sha256:01179a4a8559ab5de078078f37e5c1a30d76bb88519906844fd7bdea1b7729ff"},
+    {file = "PyYAML-6.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:688ba32a1cffef67fd2e9398a2efebaea461578b0923624778664cc1c914db5d"},
+    {file = "PyYAML-6.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a8786accb172bd8afb8be14490a16625cbc387036876ab6ba70912730faf8e1f"},
+    {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e03406cac8513435335dbab54c0d385e4a49e4945d2909a581c83647ca0290"},
+    {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f753120cb8181e736c57ef7636e83f31b9c0d1722c516f7e86cf15b7aa57ff12"},
+    {file = "PyYAML-6.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3b1fdb9dc17f5a7677423d508ab4f243a726dea51fa5e70992e59a7411c89d19"},
+    {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:0b69e4ce7a131fe56b7e4d770c67429700908fc0752af059838b1cfb41960e4e"},
+    {file = "PyYAML-6.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:a9f8c2e67970f13b16084e04f134610fd1d374bf477b17ec1599185cf611d725"},
+    {file = "PyYAML-6.0.2-cp39-cp39-win32.whl", hash = "sha256:6395c297d42274772abc367baaa79683958044e5d3835486c16da75d2a694631"},
+    {file = "PyYAML-6.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:39693e1f8320ae4f43943590b49779ffb98acb81f788220ea932a6b6c51004d8"},
+    {file = "pyyaml-6.0.2.tar.gz", hash = "sha256:d584d9ec91ad65861cc08d42e834324ef890a082e591037abe114850ff7bbc3e"},
 ]
 
 [[package]]
 name = "requests"
-version = "2.31.0"
+version = "2.32.3"
 description = "Python HTTP for Humans."
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "requests-2.31.0-py3-none-any.whl", hash = "sha256:58cd2187c01e70e6e26505bca751777aa9f2ee0b7f4300988b709f44e013003f"},
-    {file = "requests-2.31.0.tar.gz", hash = "sha256:942c5a758f98d790eaed1a29cb6eefc7ffb0d1cf7af05c3d2791656dbd6ad1e1"},
+    {file = "requests-2.32.3-py3-none-any.whl", hash = "sha256:70761cfe03c773ceb22aa2f671b4757976145175cdfca038c02654d061d6dcc6"},
+    {file = "requests-2.32.3.tar.gz", hash = "sha256:55365417734eb18255590a9ff9eb97e9e1da868d4ccd6402399eaf68af20a760"},
 ]
 
 [package.dependencies]
@@ -448,66 +592,83 @@ use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"]
 
 [[package]]
 name = "ruff"
-version = "0.3.3"
+version = "0.3.7"
 description = "An extremely fast Python linter and code formatter, written in Rust."
 optional = false
 python-versions = ">=3.7"
+groups = ["dev"]
 files = [
-    {file = "ruff-0.3.3-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:973a0e388b7bc2e9148c7f9be8b8c6ae7471b9be37e1cc732f8f44a6f6d7720d"},
-    {file = "ruff-0.3.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:cfa60d23269d6e2031129b053fdb4e5a7b0637fc6c9c0586737b962b2f834493"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1eca7ff7a47043cf6ce5c7f45f603b09121a7cc047447744b029d1b719278eb5"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e7d3f6762217c1da954de24b4a1a70515630d29f71e268ec5000afe81377642d"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b24c19e8598916d9c6f5a5437671f55ee93c212a2c4c569605dc3842b6820386"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:5a6cbf216b69c7090f0fe4669501a27326c34e119068c1494f35aaf4cc683778"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:352e95ead6964974b234e16ba8a66dad102ec7bf8ac064a23f95371d8b198aab"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:8d6ab88c81c4040a817aa432484e838aaddf8bfd7ca70e4e615482757acb64f8"},
-    {file = "ruff-0.3.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:79bca3a03a759cc773fca69e0bdeac8abd1c13c31b798d5bb3c9da4a03144a9f"},
-    {file = "ruff-0.3.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:2700a804d5336bcffe063fd789ca2c7b02b552d2e323a336700abb8ae9e6a3f8"},
-    {file = "ruff-0.3.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:fd66469f1a18fdb9d32e22b79f486223052ddf057dc56dea0caaf1a47bdfaf4e"},
-    {file = "ruff-0.3.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:45817af234605525cdf6317005923bf532514e1ea3d9270acf61ca2440691376"},
-    {file = "ruff-0.3.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:0da458989ce0159555ef224d5b7c24d3d2e4bf4c300b85467b08c3261c6bc6a8"},
-    {file = "ruff-0.3.3-py3-none-win32.whl", hash = "sha256:f2831ec6a580a97f1ea82ea1eda0401c3cdf512cf2045fa3c85e8ef109e87de0"},
-    {file = "ruff-0.3.3-py3-none-win_amd64.whl", hash = "sha256:be90bcae57c24d9f9d023b12d627e958eb55f595428bafcb7fec0791ad25ddfc"},
-    {file = "ruff-0.3.3-py3-none-win_arm64.whl", hash = "sha256:0171aab5fecdc54383993389710a3d1227f2da124d76a2784a7098e818f92d61"},
-    {file = "ruff-0.3.3.tar.gz", hash = "sha256:38671be06f57a2f8aba957d9f701ea889aa5736be806f18c0cd03d6ff0cbca8d"},
+    {file = "ruff-0.3.7-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0e8377cccb2f07abd25e84fc5b2cbe48eeb0fea9f1719cad7caedb061d70e5ce"},
+    {file = "ruff-0.3.7-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:15a4d1cc1e64e556fa0d67bfd388fed416b7f3b26d5d1c3e7d192c897e39ba4b"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d28bdf3d7dc71dd46929fafeec98ba89b7c3550c3f0978e36389b5631b793663"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:379b67d4f49774ba679593b232dcd90d9e10f04d96e3c8ce4a28037ae473f7bb"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c060aea8ad5ef21cdfbbe05475ab5104ce7827b639a78dd55383a6e9895b7c51"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:ebf8f615dde968272d70502c083ebf963b6781aacd3079081e03b32adfe4d58a"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d48098bd8f5c38897b03604f5428901b65e3c97d40b3952e38637b5404b739a2"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:da8a4fda219bf9024692b1bc68c9cff4b80507879ada8769dc7e985755d662ea"},
+    {file = "ruff-0.3.7-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c44e0149f1d8b48c4d5c33d88c677a4aa22fd09b1683d6a7ff55b816b5d074f"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3050ec0af72b709a62ecc2aca941b9cd479a7bf2b36cc4562f0033d688e44fa1"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:a29cc38e4c1ab00da18a3f6777f8b50099d73326981bb7d182e54a9a21bb4ff7"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_i686.whl", hash = "sha256:5b15cc59c19edca917f51b1956637db47e200b0fc5e6e1878233d3a938384b0b"},
+    {file = "ruff-0.3.7-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:e491045781b1e38b72c91247cf4634f040f8d0cb3e6d3d64d38dcf43616650b4"},
+    {file = "ruff-0.3.7-py3-none-win32.whl", hash = "sha256:bc931de87593d64fad3a22e201e55ad76271f1d5bfc44e1a1887edd0903c7d9f"},
+    {file = "ruff-0.3.7-py3-none-win_amd64.whl", hash = "sha256:5ef0e501e1e39f35e03c2acb1d1238c595b8bb36cf7a170e7c1df1b73da00e74"},
+    {file = "ruff-0.3.7-py3-none-win_arm64.whl", hash = "sha256:789e144f6dc7019d1f92a812891c645274ed08af6037d11fc65fcbc183b7d59f"},
+    {file = "ruff-0.3.7.tar.gz", hash = "sha256:d5c1aebee5162c2226784800ae031f660c350e7a3402c4d1f8ea4e97e232e3ba"},
 ]
 
 [[package]]
-name = "setuptools"
-version = "69.2.0"
-description = "Easily download, build, install, upgrade, and uninstall Python packages"
+name = "semver"
+version = "3.0.4"
+description = "Python helper for Semantic Versioning (https://semver.org)"
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.7"
+groups = ["dev"]
 files = [
-    {file = "setuptools-69.2.0-py3-none-any.whl", hash = "sha256:c21c49fb1042386df081cb5d86759792ab89efca84cf114889191cd09aacc80c"},
-    {file = "setuptools-69.2.0.tar.gz", hash = "sha256:0ff4183f8f42cd8fa3acea16c45205521a4ef28f73c6391d8a25e92893134f2e"},
-]
-
-[package.extras]
-docs = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "pygments-github-lexers (==0.0.5)", "rst.linker (>=1.9)", "sphinx (<7.2.5)", "sphinx (>=3.5)", "sphinx-favicon", "sphinx-inline-tabs", "sphinx-lint", "sphinx-notfound-page (>=1,<2)", "sphinx-reredirects", "sphinxcontrib-towncrier"]
-testing = ["build[virtualenv]", "filelock (>=3.4.0)", "importlib-metadata", "ini2toml[lite] (>=0.9)", "jaraco.develop (>=7.21)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "mypy (==1.9)", "packaging (>=23.2)", "pip (>=19.1)", "pytest (>=6)", "pytest-checkdocs (>=2.4)", "pytest-cov", "pytest-enabler (>=2.2)", "pytest-home (>=0.5)", "pytest-mypy (>=0.9.1)", "pytest-perf", "pytest-ruff (>=0.2.1)", "pytest-timeout", "pytest-xdist (>=3)", "tomli", "tomli-w (>=1.0.0)", "virtualenv (>=13.0.0)", "wheel"]
-testing-integration = ["build[virtualenv] (>=1.0.3)", "filelock (>=3.4.0)", "jaraco.envs (>=2.2)", "jaraco.path (>=3.2.0)", "packaging (>=23.2)", "pytest", "pytest-enabler", "pytest-xdist", "tomli", "virtualenv (>=13.0.0)", "wheel"]
-
-[[package]]
-name = "six"
-version = "1.16.0"
-description = "Python 2 and 3 compatibility utilities"
-optional = false
-python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
-files = [
-    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
-    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
+    {file = "semver-3.0.4-py3-none-any.whl", hash = "sha256:9c824d87ba7f7ab4a1890799cec8596f15c1241cb473404ea1cb0c55e4b04746"},
+    {file = "semver-3.0.4.tar.gz", hash = "sha256:afc7d8c584a5ed0a11033af086e8af226a9c0b206f313e0301f8dd7b6b589602"},
 ]
 
 [[package]]
 name = "tomli"
-version = "2.0.1"
+version = "2.2.1"
 description = "A lil' TOML parser"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "tomli-2.0.1-py3-none-any.whl", hash = "sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc"},
-    {file = "tomli-2.0.1.tar.gz", hash = "sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f"},
+    {file = "tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249"},
+    {file = "tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6"},
+    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a"},
+    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee"},
+    {file = "tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e"},
+    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4"},
+    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106"},
+    {file = "tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8"},
+    {file = "tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff"},
+    {file = "tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b"},
+    {file = "tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea"},
+    {file = "tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8"},
+    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192"},
+    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222"},
+    {file = "tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77"},
+    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6"},
+    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd"},
+    {file = "tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e"},
+    {file = "tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98"},
+    {file = "tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4"},
+    {file = "tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7"},
+    {file = "tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c"},
+    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13"},
+    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281"},
+    {file = "tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272"},
+    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140"},
+    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2"},
+    {file = "tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744"},
+    {file = "tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec"},
+    {file = "tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69"},
+    {file = "tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc"},
+    {file = "tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff"},
 ]
 
 [[package]]
@@ -516,6 +677,7 @@ version = "1.3.8"
 description = "ASCII transliterations of Unicode text"
 optional = false
 python-versions = ">=3.5"
+groups = ["dev"]
 files = [
     {file = "Unidecode-1.3.8-py3-none-any.whl", hash = "sha256:d130a61ce6696f8148a3bd8fe779c99adeb4b870584eeb9526584e9aa091fd39"},
     {file = "Unidecode-1.3.8.tar.gz", hash = "sha256:cfdb349d46ed3873ece4586b96aa75258726e2fa8ec21d6f00a591d98806c2f4"},
@@ -523,30 +685,32 @@ files = [
 
 [[package]]
 name = "urllib3"
-version = "2.2.1"
+version = "2.3.0"
 description = "HTTP library with thread-safe connection pooling, file post, and more."
 optional = false
-python-versions = ">=3.8"
+python-versions = ">=3.9"
+groups = ["dev"]
 files = [
-    {file = "urllib3-2.2.1-py3-none-any.whl", hash = "sha256:450b20ec296a467077128bff42b73080516e71b56ff59a60a02bef2232c4fa9d"},
-    {file = "urllib3-2.2.1.tar.gz", hash = "sha256:d0570876c61ab9e520d776c38acbbb5b05a776d3f9ff98a5c8fd5162a444cf19"},
+    {file = "urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df"},
+    {file = "urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d"},
 ]
 
 [package.extras]
-brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"]
+brotli = ["brotli (>=1.0.9) ; platform_python_implementation == \"CPython\"", "brotlicffi (>=0.8.0) ; platform_python_implementation != \"CPython\""]
 h2 = ["h2 (>=4,<5)"]
 socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"]
 zstd = ["zstandard (>=0.18.0)"]
 
 [[package]]
 name = "virtualenv"
-version = "20.25.1"
+version = "20.29.2"
 description = "Virtual Python Environment builder"
 optional = false
-python-versions = ">=3.7"
+python-versions = ">=3.8"
+groups = ["dev"]
 files = [
-    {file = "virtualenv-20.25.1-py3-none-any.whl", hash = "sha256:961c026ac520bac5f69acb8ea063e8a4f071bcc9457b9c1f28f6b085c511583a"},
-    {file = "virtualenv-20.25.1.tar.gz", hash = "sha256:e08e13ecdca7a0bd53798f356d5831434afa5b07b93f0abdf0797b7a06ffe197"},
+    {file = "virtualenv-20.29.2-py3-none-any.whl", hash = "sha256:febddfc3d1ea571bdb1dc0f98d7b45d24def7428214d4fb73cc486c9568cce6a"},
+    {file = "virtualenv-20.29.2.tar.gz", hash = "sha256:fdaabebf6d03b5ba83ae0a02cfe96f48a716f4fae556461d180825866f75b728"},
 ]
 
 [package.dependencies]
@@ -555,10 +719,10 @@ filelock = ">=3.12.2,<4"
 platformdirs = ">=3.9.1,<5"
 
 [package.extras]
-docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
-test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8)", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10)"]
+docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"]
+test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""]
 
 [metadata]
-lock-version = "2.0"
+lock-version = "2.1"
 python-versions = ">=3.9.1,<3.10"
-content-hash = "1bb724694792fbc2b3c05e3355e6c25305d9f4034eb7b1b4b1791ee95427f8d2"
+content-hash = "0a399d239c49db714c1166c20286fdd5cd62faf12e45ab85833c4d6ea7a04a2a"

pyproject.toml

@@ -5,16 +5,16 @@
 
 [tool.poetry]
 name = "ayon-core"
-version = "1.1.0+dev"
+version = "1.1.3+dev"
 description = ""
 authors = ["Ynput Team <team@ynput.io>"]
 readme = "README.md"
+package-mode = false
 
 [tool.poetry.dependencies]
 python = ">=3.9.1,<3.10"
 
-
-[tool.poetry.dev-dependencies]
+[tool.poetry.group.dev.dependencies]
 # test dependencies
 pytest = "^8.0"
 pytest-print = "^1.0"
@@ -24,6 +24,11 @@ ruff = "^0.3.3"
 pre-commit = "^3.6.2"
 codespell = "^2.2.6"
 semver = "^3.0.2"
+mock = "^5.0.0"
+attrs = "^25.0.0"
+pyblish-base = "^1.8.7"
+clique = "^2.0.0"
+opentimelineio = "^0.17.0"
 
 
 [tool.ruff]

server/settings/publish_plugins.py

@@ -68,6 +68,67 @@ class ContributionLayersModel(BaseSettingsModel):
                     "layer on top.")
 
 
+class CollectUSDLayerContributionsProfileModel(BaseSettingsModel):
+    """Profiles to define instance attribute defaults for USD contribution."""
+    _layout = "expanded"
+    product_types: list[str] = SettingsField(
+        default_factory=list,
+        title="Product types",
+        description=(
+            "The product types to match this profile to. When matched, the"
+            " settings below would apply to the instance as default"
+            " attributes."
+        ),
+        section="Filter"
+    )
+    task_types: list[str] = SettingsField(
+        default_factory=list,
+        title="Task Types",
+        enum_resolver=task_types_enum,
+        description=(
+            "The current create context task type to filter against. This"
+            " allows to filter the profile to only be valid if currently "
+            " creating from within that task type."
+        ),
+    )
+    contribution_enabled: bool = SettingsField(
+        True,
+        title="Contribution Enabled (default)",
+        description=(
+            "The default state for USD Contribution being marked enabled or"
+            " disabled for this profile."
+        ),
+        section="Instance attribute defaults",
+    )
+    contribution_layer: str = SettingsField(
+        "",
+        title="Contribution Department Layer",
+        description=(
+            "The default contribution layer to apply the contribution to when"
+            " matching this profile. The layer name should be in the"
+            " 'Department Layer Orders' list to get a sensible order."
+        ),
+    )
+    contribution_apply_as_variant: bool = SettingsField(
+        True,
+        title="Apply as variant",
+        description=(
+            "The default 'Apply as variant' state for instances matching this"
+            " profile. Usually enabled for asset contributions and disabled"
+            " for shot contributions."
+        ),
+    )
+    contribution_target_product: str = SettingsField(
+        "usdAsset",
+        title="Target Product",
+        description=(
+            "The default destination product name to apply the contribution to"
+            " when matching this profile."
+            " Usually e.g. 'usdAsset' or 'usdShot'."
+        ),
+    )
+
+
 class CollectUSDLayerContributionsModel(BaseSettingsModel):
     enabled: bool = SettingsField(True, title="Enabled")
     contribution_layers: list[ContributionLayersModel] = SettingsField(
@@ -77,6 +138,14 @@ class CollectUSDLayerContributionsModel(BaseSettingsModel):
             "ordering inside the USD contribution workflow."
         )
     )
+    profiles: list[CollectUSDLayerContributionsProfileModel] = SettingsField(
+        default_factory=list,
+        title="Profiles",
+        description=(
+            "Define attribute defaults for USD Contributions on publish"
+            " instances."
+        )
+    )
 
     @validator("contribution_layers")
     def validate_unique_outputs(cls, value):
@@ -1017,6 +1086,48 @@ DEFAULT_PUBLISH_VALUES = {
             {"name": "fx", "order": 500},
             {"name": "lighting", "order": 600},
         ],
+        "profiles": [
+            {
+                "product_types": ["model"],
+                "task_types": [],
+                "contribution_enabled": True,
+                "contribution_layer": "model",
+                "contribution_apply_as_variant": True,
+                "contribution_target_product": "usdAsset"
+            },
+            {
+                "product_types": ["look"],
+                "task_types": [],
+                "contribution_enabled": True,
+                "contribution_layer": "look",
+                "contribution_apply_as_variant": True,
+                "contribution_target_product": "usdAsset"
+            },
+            {
+                "product_types": ["groom"],
+                "task_types": [],
+                "contribution_enabled": True,
+                "contribution_layer": "groom",
+                "contribution_apply_as_variant": True,
+                "contribution_target_product": "usdAsset"
+            },
+            {
+                "product_types": ["rig"],
+                "task_types": [],
+                "contribution_enabled": True,
+                "contribution_layer": "rig",
+                "contribution_apply_as_variant": True,
+                "contribution_target_product": "usdAsset"
+            },
+            {
+                "product_types": ["usd"],
+                "task_types": [],
+                "contribution_enabled": True,
+                "contribution_layer": "assembly",
+                "contribution_apply_as_variant": False,
+                "contribution_target_product": "usdShot"
+            },
+        ]
     },
     "ValidateEditorialAssetName": {
         "enabled": True,

tests/client/ayon_core/lib/test_env_tools.py

@@ -0,0 +1,135 @@
+import unittest
+from unittest.mock import patch
+
+from ayon_core.lib.env_tools import (
+    CycleError,
+    DynamicKeyClashError,
+    parse_env_variables_structure,
+    compute_env_variables_structure,
+)
+
+# --- Test data ---
+COMPUTE_SRC_ENV = {
+    "COMPUTE_VERSION": "1.0.0",
+    # Will be available only for darwin
+    "COMPUTE_ONE_PLATFORM": {
+        "darwin": "Compute macOs",
+    },
+    "COMPUTE_LOCATION": {
+        "darwin": "/compute-app-{COMPUTE_VERSION}",
+        "linux": "/usr/compute-app-{COMPUTE_VERSION}",
+        "windows": "C:/Program Files/compute-app-{COMPUTE_VERSION}"
+    },
+    "PATH_LIST": {
+        "darwin": ["{COMPUTE_LOCATION}/bin", "{COMPUTE_LOCATION}/bin2"],
+        "linux": ["{COMPUTE_LOCATION}/bin", "{COMPUTE_LOCATION}/bin2"],
+        "windows": ["{COMPUTE_LOCATION}/bin", "{COMPUTE_LOCATION}/bin2"],
+    },
+    "PATH_STR": {
+        "darwin": "{COMPUTE_LOCATION}/bin:{COMPUTE_LOCATION}/bin2",
+        "linux": "{COMPUTE_LOCATION}/bin:{COMPUTE_LOCATION}/bin2",
+        "windows": "{COMPUTE_LOCATION}/bin;{COMPUTE_LOCATION}/bin2",
+    },
+}
+
+# --- RESULTS ---
+# --- Parse results ---
+PARSE_RESULT_WINDOWS = {
+    "COMPUTE_VERSION": "1.0.0",
+    "COMPUTE_LOCATION": "C:/Program Files/compute-app-{COMPUTE_VERSION}",
+    "PATH_LIST": "{COMPUTE_LOCATION}/bin;{COMPUTE_LOCATION}/bin2",
+    "PATH_STR": "{COMPUTE_LOCATION}/bin;{COMPUTE_LOCATION}/bin2",
+}
+
+PARSE_RESULT_LINUX = {
+    "COMPUTE_VERSION": "1.0.0",
+    "COMPUTE_LOCATION": "/usr/compute-app-{COMPUTE_VERSION}",
+    "PATH_LIST": "{COMPUTE_LOCATION}/bin:{COMPUTE_LOCATION}/bin2",
+    "PATH_STR": "{COMPUTE_LOCATION}/bin:{COMPUTE_LOCATION}/bin2",
+}
+
+PARSE_RESULT_DARWIN = {
+    "COMPUTE_VERSION": "1.0.0",
+    "COMPUTE_ONE_PLATFORM": "Compute macOs",
+    "COMPUTE_LOCATION": "/compute-app-{COMPUTE_VERSION}",
+    "PATH_LIST": "{COMPUTE_LOCATION}/bin:{COMPUTE_LOCATION}/bin2",
+    "PATH_STR": "{COMPUTE_LOCATION}/bin:{COMPUTE_LOCATION}/bin2",
+}
+
+# --- Compute results ---
+COMPUTE_RESULT_WINDOWS = {
+    "COMPUTE_VERSION": "1.0.0",
+    "COMPUTE_LOCATION": "C:/Program Files/compute-app-1.0.0",
+    "PATH_LIST": (
+        "C:/Program Files/compute-app-1.0.0/bin"
+        ";C:/Program Files/compute-app-1.0.0/bin2"
+    ),
+    "PATH_STR": (
+        "C:/Program Files/compute-app-1.0.0/bin"
+        ";C:/Program Files/compute-app-1.0.0/bin2"
+    )
+}
+
+COMPUTE_RESULT_LINUX = {
+    "COMPUTE_VERSION": "1.0.0",
+    "COMPUTE_LOCATION": "/usr/compute-app-1.0.0",
+    "PATH_LIST": "/usr/compute-app-1.0.0/bin:/usr/compute-app-1.0.0/bin2",
+    "PATH_STR": "/usr/compute-app-1.0.0/bin:/usr/compute-app-1.0.0/bin2"
+}
+
+COMPUTE_RESULT_DARWIN = {
+    "COMPUTE_VERSION": "1.0.0",
+    "COMPUTE_ONE_PLATFORM": "Compute macOs",
+    "COMPUTE_LOCATION": "/compute-app-1.0.0",
+    "PATH_LIST": "/compute-app-1.0.0/bin:/compute-app-1.0.0/bin2",
+    "PATH_STR": "/compute-app-1.0.0/bin:/compute-app-1.0.0/bin2"
+}
+
+
+class EnvParseCompute(unittest.TestCase):
+    def test_parse_env(self):
+        with patch("platform.system", return_value="windows"):
+            result = parse_env_variables_structure(COMPUTE_SRC_ENV)
+            assert result == PARSE_RESULT_WINDOWS
+
+        with patch("platform.system", return_value="linux"):
+            result = parse_env_variables_structure(COMPUTE_SRC_ENV)
+            assert result == PARSE_RESULT_LINUX
+
+        with patch("platform.system", return_value="darwin"):
+            result = parse_env_variables_structure(COMPUTE_SRC_ENV)
+            assert result == PARSE_RESULT_DARWIN
+
+    def test_compute_env(self):
+        with patch("platform.system", return_value="windows"):
+            result = compute_env_variables_structure(
+                parse_env_variables_structure(COMPUTE_SRC_ENV)
+            )
+            assert result == COMPUTE_RESULT_WINDOWS
+
+        with patch("platform.system", return_value="linux"):
+            result = compute_env_variables_structure(
+                parse_env_variables_structure(COMPUTE_SRC_ENV)
+            )
+            assert result == COMPUTE_RESULT_LINUX
+
+        with patch("platform.system", return_value="darwin"):
+            result = compute_env_variables_structure(
+                parse_env_variables_structure(COMPUTE_SRC_ENV)
+            )
+            assert result == COMPUTE_RESULT_DARWIN
+
+    def test_cycle_error(self):
+        with self.assertRaises(CycleError):
+            compute_env_variables_structure({
+                "KEY_1": "{KEY_2}",
+                "KEY_2": "{KEY_1}",
+            })
+
+    def test_dynamic_key_error(self):
+        with self.assertRaises(DynamicKeyClashError):
+            compute_env_variables_structure({
+                "KEY_A": "Occupied",
+                "SUBKEY": "A",
+                "KEY_{SUBKEY}": "Resolves as occupied key",
+            })

tests/client/ayon_core/pipeline/editorial/test_collect_otio_frame_ranges.py

@@ -0,0 +1,128 @@
+import os
+
+import opentimelineio as otio
+
+from ayon_core.plugins.publish import collect_otio_frame_ranges
+
+
+_RESOURCE_DIR = os.path.join(
+    os.path.dirname(__file__),
+    "resources",
+    "timeline"
+)
+
+
+class MockInstance():
+    """ Mock pyblish instance for testing purpose.
+    """
+    def __init__(self, data: dict):
+        self.data = data
+        self.context = self
+
+
+def _check_expected_frame_range_values(
+    clip_name: str,
+    expected_data: dict,
+    handle_start: int = 10,
+    handle_end: int = 10,
+    retimed: bool = False,
+):
+    file_path = os.path.join(_RESOURCE_DIR, "timeline.json")
+    otio_timeline = otio.schema.Timeline.from_json_file(file_path)
+
+    for otio_clip in otio_timeline.find_clips():
+        if otio_clip.name == clip_name:
+            break
+
+    instance_data = {
+        "otioClip": otio_clip,
+        "handleStart": handle_start,
+        "handleEnd": handle_end,
+        "workfileFrameStart": 1001,
+    }
+    if retimed:
+        instance_data["shotDurationFromSource"] = True
+
+    instance = MockInstance(instance_data)
+
+    processor = collect_otio_frame_ranges.CollectOtioRanges()
+    processor.process(instance)
+
+    # Assert expected data is subset of edited instance.
+    assert expected_data.items() <= instance.data.items()
+
+
+def test_movie_with_timecode():
+    """
+    Movie clip (with embedded timecode)
+    available_range = 86531-86590 23.976fps
+    source_range = 86535-86586 23.976fps
+    """
+    expected_data = {
+        'frameStart': 1001,
+        'frameEnd': 1052,
+        'clipIn': 24,
+        'clipOut': 75,
+        'clipInH': 14,
+        'clipOutH': 85,
+        'sourceStart': 86535,
+        'sourceStartH': 86525,
+        'sourceEnd': 86586,
+        'sourceEndH': 86596,
+    }
+
+    _check_expected_frame_range_values(
+        "sh010",
+        expected_data,
+    )
+
+
+def test_image_sequence():
+    """
+    EXR image sequence.
+    available_range = 87399-87482 24fps
+    source_range = 87311-87336 23.976fps
+    """
+    expected_data = {
+        'frameStart': 1001,
+        'frameEnd': 1026,
+        'clipIn': 76,
+        'clipOut': 101,
+        'clipInH': 66,
+        'clipOutH': 111,
+        'sourceStart': 87399,
+        'sourceStartH': 87389,
+        'sourceEnd': 87424,
+        'sourceEndH': 87434,
+    }
+
+    _check_expected_frame_range_values(
+        "img_sequence_exr",
+        expected_data,
+    )
+
+def test_media_retimed():
+    """
+    EXR image sequence.
+    available_range = 345619-345691 23.976fps
+    source_range = 345623-345687 23.976fps
+    TimeWarp = frozen frame.
+    """
+    expected_data = {
+        'frameStart': 1001,
+        'frameEnd': 1065,
+        'clipIn': 127,
+        'clipOut': 191,
+        'clipInH': 117,
+        'clipOutH': 201,
+        'sourceStart': 1001,
+        'sourceStartH': 1001,
+        'sourceEnd': 1065,
+        'sourceEndH': 1065,
+    }
+
+    _check_expected_frame_range_values(
+        "P01default_twsh010",
+        expected_data,
+        retimed=True,
+    )

tools/manage.ps1

@@ -240,6 +240,13 @@ function Run-From-Code {
     & $Poetry $RunArgs @arguments
 }
 
+function Run-Tests {
+    $Poetry = "$RepoRoot\.poetry\bin\poetry.exe"
+    $RunArgs = @( "run", "pytest", "$($RepoRoot)/tests")
+
+    & $Poetry $RunArgs @arguments
+}
+
 function Write-Help {
     <#
     .SYNOPSIS
@@ -256,6 +263,7 @@ function Write-Help {
     Write-Info -Text "  ruff-fix                      ", "Run Ruff fix for the repository" -Color White, Cyan
     Write-Info -Text "  codespell                     ", "Run codespell check for the repository" -Color White, Cyan
     Write-Info -Text "  run                           ", "Run a poetry command in the repository environment" -Color White, Cyan
+    Write-Info -Text "  run-tests                     ", "Run ayon-core tests" -Color White, Cyan
     Write-Host ""
 }
 
@@ -280,6 +288,9 @@ function Resolve-Function {
     } elseif ($FunctionName -eq "run") {
         Set-Cwd
         Run-From-Code
+    } elseif ($FunctionName -eq "runtests") {
+        Set-Cwd
+        Run-Tests
     } else {
         Write-Host "Unknown function ""$FunctionName"""
         Write-Help

tools/manage.sh

@@ -158,6 +158,7 @@ default_help() {
   echo -e "  ${BWhite}ruff-fix${RST}        ${BCyan}Run Ruff fix for the repository${RST}"
   echo -e "  ${BWhite}codespell${RST}       ${BCyan}Run codespell check for the repository${RST}"
   echo -e "  ${BWhite}run${RST}             ${BCyan}Run a poetry command in the repository environment${RST}"
+  echo -e "  ${BWhite}run-tests${RST}       ${BCyan}Run ayon-core tests${RST}"
   echo ""
 }
 
@@ -182,6 +183,12 @@ run_command () {
   "$POETRY_HOME/bin/poetry" run "$@"
 }
 
+run_tests () {
+  echo -e "${BIGreen}>>>${RST} Running tests..."
+  shift;  # will remove first arg ("run-tests") from the "$@"
+  "$POETRY_HOME/bin/poetry" run pytest ./tests
+}
+
 main () {
   detect_python || return 1
 
@@ -218,6 +225,10 @@ main () {
       run_command "$@" || return_code=$?
       exit $return_code
       ;;
+    "runtests")
+      run_tests "$@" || return_code=$?
+      exit $return_code
+      ;;
   esac
 
   if [ "$function_name" != "" ]; then