From 640c24d9b70665d1ecec6cf293759c213eaf4271 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Mon, 15 Jul 2024 15:33:39 +0200
Subject: [PATCH 1/8] add 'parents' to folder template data

---
 client/ayon_core/pipeline/template_data.py          | 13 +++++++------
 .../publish/collect_anatomy_instance_data.py        |  5 ++++-
 2 files changed, 11 insertions(+), 7 deletions(-)

diff --git a/client/ayon_core/pipeline/template_data.py b/client/ayon_core/pipeline/template_data.py
index d5f06d6a59..2c5346f14b 100644
--- a/client/ayon_core/pipeline/template_data.py
+++ b/client/ayon_core/pipeline/template_data.py
@@ -87,14 +87,14 @@ def get_folder_template_data(folder_entity, project_name):
     """
 
     path = folder_entity["path"]
-    hierarchy_parts = path.split("/")
+    parents = path.split("/")
     # Remove empty string from the beginning
-    hierarchy_parts.pop(0)
+    parents.pop(0)
     # Remove last part which is folder name
-    folder_name = hierarchy_parts.pop(-1)
-    hierarchy = "/".join(hierarchy_parts)
-    if hierarchy_parts:
-        parent_name = hierarchy_parts[-1]
+    folder_name = parents.pop(-1)
+    hierarchy = "/".join(parents)
+    if parents:
+        parent_name = parents[-1]
     else:
         parent_name = project_name
 
@@ -103,6 +103,7 @@ def get_folder_template_data(folder_entity, project_name):
             "name": folder_name,
             "type": folder_entity["folderType"],
             "path": path,
+            "parents": parents,
         },
         "asset": folder_name,
         "hierarchy": hierarchy,
diff --git a/client/ayon_core/plugins/publish/collect_anatomy_instance_data.py b/client/ayon_core/plugins/publish/collect_anatomy_instance_data.py
index b6636696c1..6eeca6ad29 100644
--- a/client/ayon_core/plugins/publish/collect_anatomy_instance_data.py
+++ b/client/ayon_core/plugins/publish/collect_anatomy_instance_data.py
@@ -407,8 +407,10 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
             anatomy_data["hierarchy"] = hierarchy
 
             parent_name = project_entity["name"]
+            parents = []
             if hierarchy:
-                parent_name = hierarchy.split("/")[-1]
+                parents = hierarchy.split("/")
+                parent_name = parents[-1]
 
             folder_name = instance.data["folderPath"].split("/")[-1]
             anatomy_data.update({
@@ -422,6 +424,7 @@ class CollectAnatomyInstanceData(pyblish.api.ContextPlugin):
                     #   Using 'Shot' is current default behavior of editorial
                     #   (or 'newHierarchyIntegration') publishing.
                     "type": "Shot",
+                    "parents": parents,
                 },
             })
 

From c08d0baa88839020caa7e9372fb286f100d56fc3 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Mon, 15 Jul 2024 15:57:55 +0200
Subject: [PATCH 2/8] simplify split

---
 client/ayon_core/pipeline/template_data.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/client/ayon_core/pipeline/template_data.py b/client/ayon_core/pipeline/template_data.py
index 2c5346f14b..c7aa46fd62 100644
--- a/client/ayon_core/pipeline/template_data.py
+++ b/client/ayon_core/pipeline/template_data.py
@@ -87,9 +87,8 @@ def get_folder_template_data(folder_entity, project_name):
     """
 
     path = folder_entity["path"]
-    parents = path.split("/")
-    # Remove empty string from the beginning
-    parents.pop(0)
+    # Remove empty string from the beginning and split by '/'
+    parents = path.lstrip("/").split("/")
     # Remove last part which is folder name
     folder_name = parents.pop(-1)
     hierarchy = "/".join(parents)

From 26251bb9b4ebae496ab7aab0a7a3e0a1a95c1611 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Thu, 21 Nov 2024 18:29:31 +0100
Subject: [PATCH 3/8] simplified parsing of template

---
 client/ayon_core/lib/path_templates.py | 19 ++++++++++---------
 1 file changed, 10 insertions(+), 9 deletions(-)

diff --git a/client/ayon_core/lib/path_templates.py b/client/ayon_core/lib/path_templates.py
index dc88ec956b..1a99ae459d 100644
--- a/client/ayon_core/lib/path_templates.py
+++ b/client/ayon_core/lib/path_templates.py
@@ -1,6 +1,7 @@
 import os
 import re
 import numbers
+from string import Formatter
 
 KEY_PATTERN = re.compile(r"(\{.*?[^{0]*\})")
 KEY_PADDING_PATTERN = re.compile(r"([^:]+)\S+[><]\S+")
@@ -48,16 +49,16 @@ class StringTemplate:
 
         self._template = template
         parts = []
-        last_end_idx = 0
-        for item in KEY_PATTERN.finditer(template):
-            start, end = item.span()
-            if start > last_end_idx:
-                parts.append(template[last_end_idx:start])
-            parts.append(FormattingPart(template[start:end]))
-            last_end_idx = end
+        formatter = Formatter()
 
-        if last_end_idx < len(template):
-            parts.append(template[last_end_idx:len(template)])
+        for item in formatter.parse(template):
+            literal_text, field_name, format_spec, conversion = item
+            if literal_text:
+                parts.append(literal_text)
+            if field_name:
+                parts.append(
+                    FormattingPart(field_name, format_spec, conversion)
+                )
 
         new_parts = []
         for part in parts:

From e4875cc5096a5381861b45f45c28eb6c2a68215e Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Thu, 21 Nov 2024 18:37:34 +0100
Subject: [PATCH 4/8] fill FormattingPart init

---
 client/ayon_core/lib/path_templates.py | 17 +++++++++++++++--
 1 file changed, 15 insertions(+), 2 deletions(-)

diff --git a/client/ayon_core/lib/path_templates.py b/client/ayon_core/lib/path_templates.py
index 1a99ae459d..3871b97849 100644
--- a/client/ayon_core/lib/path_templates.py
+++ b/client/ayon_core/lib/path_templates.py
@@ -437,8 +437,21 @@ class FormattingPart:
     Args:
         template(str): String containing the formatting key.
     """
-    def __init__(self, template):
-        self._template = template
+    def __init__(self, field_name, format_spec, conversion):
+        format_spec_v = ""
+        if format_spec:
+            format_spec_v = f":{format_spec}"
+        conversion_v = ""
+        if conversion:
+            conversion_v = f"!{conversion}"
+
+        self._field_name = field_name
+        self._format_spec = format_spec_v
+        self._conversion = conversion_v
+
+        template_base = f"{field_name}{format_spec_v}{conversion_v}"
+        self._template_base = template_base
+        self._template = f"{{{template_base}}}"
 
     @property
     def template(self):

From d15148f001f17f4488119c402a54005be34e0d38 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Thu, 21 Nov 2024 18:38:49 +0100
Subject: [PATCH 5/8] support list in StringTemplate

---
 client/ayon_core/lib/path_templates.py | 122 +++++++++++++++++--------
 1 file changed, 82 insertions(+), 40 deletions(-)

diff --git a/client/ayon_core/lib/path_templates.py b/client/ayon_core/lib/path_templates.py
index 3871b97849..9b545f2851 100644
--- a/client/ayon_core/lib/path_templates.py
+++ b/client/ayon_core/lib/path_templates.py
@@ -1,10 +1,10 @@
 import os
 import re
+import copy
 import numbers
+from typing import List
 from string import Formatter
 
-KEY_PATTERN = re.compile(r"(\{.*?[^{0]*\})")
-KEY_PADDING_PATTERN = re.compile(r"([^:]+)\S+[><]\S+")
 SUB_DICT_PATTERN = re.compile(r"([^\[\]]+)")
 OPTIONAL_PATTERN = re.compile(r"(<.*?[^{0]*>)[^0-9]*?")
 
@@ -369,11 +369,10 @@ class TemplatePartResult:
     @staticmethod
     def split_keys_to_subdicts(values):
         output = {}
+        formatter = Formatter()
         for key, value in values.items():
-            key_padding = list(KEY_PADDING_PATTERN.findall(key))
-            if key_padding:
-                key = key_padding[0]
-            key_subdict = list(SUB_DICT_PATTERN.findall(key))
+            _, field_name, _, _ = next(formatter.parse(f"{{{key}}}"))
+            key_subdict = list(SUB_DICT_PATTERN.findall(field_name))
             data = output
             last_key = key_subdict.pop(-1)
             for subkey in key_subdict:
@@ -502,6 +501,16 @@ class FormattingPart:
                     return False
         return not queue
 
+    @staticmethod
+    def keys_to_template_base(keys: List[str]):
+        if not keys:
+            return None
+        # Create copy of keys
+        keys = list(keys)
+        template_base = keys.pop(0)
+        joined_keys = "".join([f"[{key}]" for key in keys])
+        return f"{template_base}{joined_keys}"
+
     def format(self, data, result):
         """Format the formattings string.
 
@@ -509,7 +518,7 @@ class FormattingPart:
             data(dict): Data that should be used for formatting.
             result(TemplatePartResult): Object where result is stored.
         """
-        key = self.template[1:-1]
+        key = self._template_base
         if key in result.realy_used_values:
             result.add_output(result.realy_used_values[key])
             return result
@@ -521,17 +530,38 @@ class FormattingPart:
             return result
 
         # check if key expects subdictionary keys (e.g. project[name])
-        existence_check = key
-        key_padding = list(KEY_PADDING_PATTERN.findall(existence_check))
-        if key_padding:
-            existence_check = key_padding[0]
-        key_subdict = list(SUB_DICT_PATTERN.findall(existence_check))
+        key_subdict = list(SUB_DICT_PATTERN.findall(self._field_name))
 
         value = data
         missing_key = False
         invalid_type = False
         used_keys = []
+        keys_to_value = None
+        used_value = None
+
         for sub_key in key_subdict:
+            if isinstance(value, list):
+                if not sub_key.lstrip("-").isdigit():
+                    invalid_type = True
+                    break
+                sub_key = int(sub_key)
+                if sub_key < 0:
+                    sub_key = len(value) + sub_key
+
+                invalid = 0 > sub_key < len(data)
+                if invalid:
+                    used_keys.append(sub_key)
+                    missing_key = True
+                    break
+
+                used_keys.append(sub_key)
+                if keys_to_value is None:
+                    keys_to_value = list(used_keys)
+                    keys_to_value.pop(-1)
+                    used_value = copy.deepcopy(value)
+                value = value[sub_key]
+                continue
+
             if (
                 value is None
                 or (hasattr(value, "items") and sub_key not in value)
@@ -547,45 +577,57 @@ class FormattingPart:
             used_keys.append(sub_key)
             value = value.get(sub_key)
 
-        if missing_key or invalid_type:
-            if len(used_keys) == 0:
-                invalid_key = key_subdict[0]
-            else:
-                invalid_key = used_keys[0]
-                for idx, sub_key in enumerate(used_keys):
-                    if idx == 0:
-                        continue
-                    invalid_key += "[{0}]".format(sub_key)
+        field_name = key_subdict[0]
+        if used_keys:
+            field_name = self.keys_to_template_base(used_keys)
 
+        if missing_key or invalid_type:
             if missing_key:
-                result.add_missing_key(invalid_key)
+                result.add_missing_key(field_name)
 
             elif invalid_type:
-                result.add_invalid_type(invalid_key, value)
+                result.add_invalid_type(field_name, value)
 
             result.add_output(self.template)
             return result
 
-        if self.validate_value_type(value):
-            fill_data = {}
-            first_value = True
-            for used_key in reversed(used_keys):
-                if first_value:
-                    first_value = False
-                    fill_data[used_key] = value
-                else:
-                    _fill_data = {used_key: fill_data}
-                    fill_data = _fill_data
-
-            formatted_value = self.template.format(**fill_data)
-            result.add_realy_used_value(key, formatted_value)
-            result.add_used_value(existence_check, formatted_value)
-            result.add_output(formatted_value)
+        if not self.validate_value_type(value):
+            result.add_invalid_type(key, value)
+            result.add_output(self.template)
             return result
 
-        result.add_invalid_type(key, value)
-        result.add_output(self.template)
+        fill_data = root_fill_data = {}
+        parent_fill_data = None
+        parent_key = None
+        fill_value = data
+        value_filled = False
+        for used_key in used_keys:
+            if isinstance(fill_value, list):
+                parent_fill_data[parent_key] = fill_value
+                value_filled = True
+                break
+            fill_value = fill_value[used_key]
+            parent_fill_data = fill_data
+            fill_data = parent_fill_data.setdefault(used_key, {})
+            parent_key = used_key
 
+        if not value_filled:
+            parent_fill_data[used_keys[-1]] = value
+
+        template = f"{{{field_name}{self._format_spec}{self._conversion}}}"
+        formatted_value = template.format(**root_fill_data)
+        used_key = key
+        if keys_to_value is not None:
+            used_key = self.keys_to_template_base(keys_to_value)
+
+        if used_value is None:
+            if isinstance(value, numbers.Number):
+                used_value = value
+            else:
+                used_value = formatted_value
+        result.add_realy_used_value(self._field_name, used_value)
+        result.add_used_value(used_key, used_value)
+        result.add_output(formatted_value)
         return result
 
 

From 9bcc9b40191d0ecdbd435e5a58e714f6dfbd86fe Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Wed, 4 Dec 2024 16:08:04 +0100
Subject: [PATCH 6/8] fix 'realy' typo to 'really'

---
 client/ayon_core/lib/path_templates.py | 35 +++++++++++++++++++-------
 1 file changed, 26 insertions(+), 9 deletions(-)

diff --git a/client/ayon_core/lib/path_templates.py b/client/ayon_core/lib/path_templates.py
index 9b545f2851..bc4ed648b7 100644
--- a/client/ayon_core/lib/path_templates.py
+++ b/client/ayon_core/lib/path_templates.py
@@ -292,7 +292,7 @@ class TemplatePartResult:
         # Used values stored by key with all modifirs
         #   - value is already formatted string
         #   Example: {"version:0>3": "001"}
-        self._realy_used_values = {}
+        self._really_used_values: Dict[str, Any] = {}
         # Concatenated string output after formatting
         self._output = ""
         # Is this result from optional part
@@ -314,7 +314,7 @@ class TemplatePartResult:
             if other.optional and not other.solved:
                 return
             self._used_values.update(other.used_values)
-            self._realy_used_values.update(other.realy_used_values)
+            self._really_used_values.update(other.really_used_values)
 
         else:
             raise TypeError("Cannot add data from \"{}\" to \"{}\"".format(
@@ -359,8 +359,17 @@ class TemplatePartResult:
         return self._invalid_optional_types
 
     @property
-    def realy_used_values(self):
-        return self._realy_used_values
+    def really_used_values(self) -> Dict[str, Any]:
+        return self._really_used_values
+
+    @property
+    def realy_used_values(self) -> Dict[str, Any]:
+        warnings.warn(
+            "Property 'realy_used_values' is deprecated."
+            " Use 'really_used_values' instead.",
+            DeprecationWarning
+        )
+        return self._really_used_values
 
     @property
     def used_values(self):
@@ -391,8 +400,16 @@ class TemplatePartResult:
 
         return self.split_keys_to_subdicts(new_used_values)
 
-    def add_realy_used_value(self, key, value):
-        self._realy_used_values[key] = value
+    def add_really_used_value(self, key: str, value: Any):
+        self._really_used_values[key] = value
+
+    def add_realy_used_value(self, key: str, value: Any):
+        warnings.warn(
+            "Method 'add_realy_used_value' is deprecated."
+            " Use 'add_really_used_value' instead.",
+            DeprecationWarning
+        )
+        self.add_really_used_value(key, value)
 
     def add_used_value(self, key, value):
         self._used_values[key] = value
@@ -519,8 +536,8 @@ class FormattingPart:
             result(TemplatePartResult): Object where result is stored.
         """
         key = self._template_base
-        if key in result.realy_used_values:
-            result.add_output(result.realy_used_values[key])
+        if key in result.really_used_values:
+            result.add_output(result.really_used_values[key])
             return result
 
         # ensure key is properly formed [({})] properly closed.
@@ -625,7 +642,7 @@ class FormattingPart:
                 used_value = value
             else:
                 used_value = formatted_value
-        result.add_realy_used_value(self._field_name, used_value)
+        result.add_really_used_value(self._field_name, used_value)
         result.add_used_value(used_key, used_value)
         result.add_output(formatted_value)
         return result

From a80bbfbd5764b33bf51e44b0e92152e6311b58e0 Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Wed, 4 Dec 2024 16:13:33 +0100
Subject: [PATCH 7/8] added basic typehints

---
 client/ayon_core/lib/path_templates.py | 174 +++++++++++++++----------
 1 file changed, 103 insertions(+), 71 deletions(-)

diff --git a/client/ayon_core/lib/path_templates.py b/client/ayon_core/lib/path_templates.py
index bc4ed648b7..3e66344ff4 100644
--- a/client/ayon_core/lib/path_templates.py
+++ b/client/ayon_core/lib/path_templates.py
@@ -2,8 +2,13 @@ import os
 import re
 import copy
 import numbers
-from typing import List
+import warnings
 from string import Formatter
+import typing
+from typing import List, Dict, Any, Set, Optional
+
+if typing.TYPE_CHECKING:
+    from typing import Union
 
 SUB_DICT_PATTERN = re.compile(r"([^\[\]]+)")
 OPTIONAL_PATTERN = re.compile(r"(<.*?[^{0]*>)[^0-9]*?")
@@ -19,9 +24,7 @@ class TemplateUnsolved(Exception):
     def __init__(self, template, missing_keys, invalid_types):
         invalid_type_items = []
         for _key, _type in invalid_types.items():
-            invalid_type_items.append(
-                "\"{0}\" {1}".format(_key, str(_type))
-            )
+            invalid_type_items.append(f"\"{_key}\" {str(_type)}")
 
         invalid_types_msg = ""
         if invalid_type_items:
@@ -34,20 +37,21 @@ class TemplateUnsolved(Exception):
             missing_keys_msg = self.missing_keys_msg.format(
                 ", ".join(missing_keys)
             )
-        super(TemplateUnsolved, self).__init__(
+        super().__init__(
             self.msg.format(template, missing_keys_msg, invalid_types_msg)
         )
 
 
 class StringTemplate:
     """String that can be formatted."""
-    def __init__(self, template):
+    def __init__(self, template: str):
         if not isinstance(template, str):
-            raise TypeError("<{}> argument must be a string, not {}.".format(
-                self.__class__.__name__, str(type(template))
-            ))
+            raise TypeError(
+                f"<{self.__class__.__name__}> argument must be a string,"
+                f" not {str(type(template))}."
+            )
 
-        self._template = template
+        self._template: str = template
         parts = []
         formatter = Formatter()
 
@@ -78,15 +82,17 @@ class StringTemplate:
             if substr:
                 new_parts.append(substr)
 
-        self._parts = self.find_optional_parts(new_parts)
+        self._parts: List["Union[str, OptionalPart, FormattingPart]"] = (
+            self.find_optional_parts(new_parts)
+        )
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self.template
 
-    def __repr__(self):
-        return "<{}> {}".format(self.__class__.__name__, self.template)
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}> {self.template}"
 
-    def __contains__(self, other):
+    def __contains__(self, other: str) -> bool:
         return other in self.template
 
     def replace(self, *args, **kwargs):
@@ -94,10 +100,10 @@ class StringTemplate:
         return self
 
     @property
-    def template(self):
+    def template(self) -> str:
         return self._template
 
-    def format(self, data):
+    def format(self, data: Dict[str, Any]) -> "TemplateResult":
         """ Figure out with whole formatting.
 
         Separate advanced keys (*Like '{project[name]}') from string which must
@@ -109,6 +115,7 @@ class StringTemplate:
         Returns:
             TemplateResult: Filled or partially filled template containing all
                 data needed or missing for filling template.
+
         """
         result = TemplatePartResult()
         for part in self._parts:
@@ -136,23 +143,29 @@ class StringTemplate:
             invalid_types
         )
 
-    def format_strict(self, *args, **kwargs):
-        result = self.format(*args, **kwargs)
+    def format_strict(self, data: Dict[str, Any]) -> "TemplateResult":
+        result = self.format(data)
         result.validate()
         return result
 
     @classmethod
-    def format_template(cls, template, data):
+    def format_template(
+        cls, template: str, data: Dict[str, Any]
+    ) -> "TemplateResult":
         objected_template = cls(template)
         return objected_template.format(data)
 
     @classmethod
-    def format_strict_template(cls, template, data):
+    def format_strict_template(
+        cls, template: str, data: Dict[str, Any]
+    ) -> "TemplateResult":
         objected_template = cls(template)
         return objected_template.format_strict(data)
 
     @staticmethod
-    def find_optional_parts(parts):
+    def find_optional_parts(
+        parts: List["Union[str, FormattingPart]"]
+    ) -> List["Union[str, OptionalPart, FormattingPart]"]:
         new_parts = []
         tmp_parts = {}
         counted_symb = -1
@@ -217,11 +230,11 @@ class TemplateResult(str):
             of number.
     """
 
-    used_values = None
-    solved = None
-    template = None
-    missing_keys = None
-    invalid_types = None
+    used_values: Dict[str, Any] = None
+    solved: bool = None
+    template: str = None
+    missing_keys: List[str] = None
+    invalid_types: Dict[str, Any] = None
 
     def __new__(
         cls, filled_template, template, solved,
@@ -249,7 +262,7 @@ class TemplateResult(str):
                 self.invalid_types
             )
 
-    def copy(self):
+    def copy(self) -> "TemplateResult":
         cls = self.__class__
         return cls(
             str(self),
@@ -260,7 +273,7 @@ class TemplateResult(str):
             self.invalid_types
         )
 
-    def normalized(self):
+    def normalized(self) -> "TemplateResult":
         """Convert to normalized path."""
 
         cls = self.__class__
@@ -276,27 +289,28 @@ class TemplateResult(str):
 
 class TemplatePartResult:
     """Result to store result of template parts."""
-    def __init__(self, optional=False):
+    def __init__(self, optional: bool = False):
         # Missing keys or invalid value types of required keys
-        self._missing_keys = set()
-        self._invalid_types = {}
+        self._missing_keys: Set[str] = set()
+        self._invalid_types: Dict[str, Any] = {}
         # Missing keys or invalid value types of optional keys
-        self._missing_optional_keys = set()
-        self._invalid_optional_types = {}
+        self._missing_optional_keys: Set[str] = set()
+        self._invalid_optional_types: Dict[str, Any] = {}
 
         # Used values stored by key with origin type
         #   - key without any padding or key modifiers
         #   - value from filling data
         #   Example: {"version": 1}
-        self._used_values = {}
+        self._used_values: Dict[str, Any] = {}
         # Used values stored by key with all modifirs
         #   - value is already formatted string
         #   Example: {"version:0>3": "001"}
         self._really_used_values: Dict[str, Any] = {}
         # Concatenated string output after formatting
-        self._output = ""
+        self._output: str = ""
         # Is this result from optional part
-        self._optional = True
+        # TODO find out why we don't use 'optional' from args
+        self._optional: bool = True
 
     def add_output(self, other):
         if isinstance(other, str):
@@ -322,7 +336,7 @@ class TemplatePartResult:
             )
 
     @property
-    def solved(self):
+    def solved(self) -> bool:
         if self.optional:
             if (
                 len(self.missing_optional_keys) > 0
@@ -335,27 +349,27 @@ class TemplatePartResult:
         )
 
     @property
-    def optional(self):
+    def optional(self) -> bool:
         return self._optional
 
     @property
-    def output(self):
+    def output(self) -> str:
         return self._output
 
     @property
-    def missing_keys(self):
+    def missing_keys(self) -> Set[str]:
         return self._missing_keys
 
     @property
-    def missing_optional_keys(self):
+    def missing_optional_keys(self) -> Set[str]:
         return self._missing_optional_keys
 
     @property
-    def invalid_types(self):
+    def invalid_types(self) -> Dict[str, Any]:
         return self._invalid_types
 
     @property
-    def invalid_optional_types(self):
+    def invalid_optional_types(self) -> Dict[str, Any]:
         return self._invalid_optional_types
 
     @property
@@ -372,11 +386,11 @@ class TemplatePartResult:
         return self._really_used_values
 
     @property
-    def used_values(self):
+    def used_values(self) -> Dict[str, Any]:
         return self._used_values
 
     @staticmethod
-    def split_keys_to_subdicts(values):
+    def split_keys_to_subdicts(values: Dict[str, Any]) -> Dict[str, Any]:
         output = {}
         formatter = Formatter()
         for key, value in values.items():
@@ -391,7 +405,7 @@ class TemplatePartResult:
             data[last_key] = value
         return output
 
-    def get_clean_used_values(self):
+    def get_clean_used_values(self) -> Dict[str, Any]:
         new_used_values = {}
         for key, value in self.used_values.items():
             if isinstance(value, FormatObject):
@@ -411,16 +425,16 @@ class TemplatePartResult:
         )
         self.add_really_used_value(key, value)
 
-    def add_used_value(self, key, value):
+    def add_used_value(self, key: str, value: Any):
         self._used_values[key] = value
 
-    def add_missing_key(self, key):
+    def add_missing_key(self, key: str):
         if self._optional:
             self._missing_optional_keys.add(key)
         else:
             self._missing_keys.add(key)
 
-    def add_invalid_type(self, key, value):
+    def add_invalid_type(self, key: str, value: Any):
         if self._optional:
             self._invalid_optional_types[key] = type(value)
         else:
@@ -438,10 +452,10 @@ class FormatObject:
     def __format__(self, *args, **kwargs):
         return self.value.__format__(*args, **kwargs)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return str(self.value)
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return self.__str__()
 
 
@@ -451,9 +465,17 @@ class FormattingPart:
     Containt only single key to format e.g. "{project[name]}".
 
     Args:
-        template(str): String containing the formatting key.
+        field_name (str): Name of key.
+        format_spec (str): Format specification.
+        conversion (Union[str, None]): Conversion type.
+
     """
-    def __init__(self, field_name, format_spec, conversion):
+    def __init__(
+        self,
+        field_name: str,
+        format_spec: str,
+        conversion: "Union[str, None]",
+    ):
         format_spec_v = ""
         if format_spec:
             format_spec_v = f":{format_spec}"
@@ -461,26 +483,26 @@ class FormattingPart:
         if conversion:
             conversion_v = f"!{conversion}"
 
-        self._field_name = field_name
-        self._format_spec = format_spec_v
-        self._conversion = conversion_v
+        self._field_name: str = field_name
+        self._format_spec: str = format_spec_v
+        self._conversion: str = conversion_v
 
         template_base = f"{field_name}{format_spec_v}{conversion_v}"
-        self._template_base = template_base
-        self._template = f"{{{template_base}}}"
+        self._template_base: str = template_base
+        self._template: str = f"{{{template_base}}}"
 
     @property
-    def template(self):
+    def template(self) -> str:
         return self._template
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<Format:{}>".format(self._template)
 
-    def __str__(self):
+    def __str__(self) -> str:
         return self._template
 
     @staticmethod
-    def validate_value_type(value):
+    def validate_value_type(value: Any) -> bool:
         """Check if value can be used for formatting of single key."""
         if isinstance(value, (numbers.Number, FormatObject)):
             return True
@@ -491,7 +513,7 @@ class FormattingPart:
         return False
 
     @staticmethod
-    def validate_key_is_matched(key):
+    def validate_key_is_matched(key: str) -> bool:
         """Validate that opening has closing at correct place.
         Future-proof, only square brackets are currently used in keys.
 
@@ -528,12 +550,15 @@ class FormattingPart:
         joined_keys = "".join([f"[{key}]" for key in keys])
         return f"{template_base}{joined_keys}"
 
-    def format(self, data, result):
+    def format(
+        self, data: Dict[str, Any], result: TemplatePartResult
+    ) -> TemplatePartResult:
         """Format the formattings string.
 
         Args:
             data(dict): Data that should be used for formatting.
             result(TemplatePartResult): Object where result is stored.
+
         """
         key = self._template_base
         if key in result.really_used_values:
@@ -658,20 +683,27 @@ class OptionalPart:
             'FormattingPart'.
     """
 
-    def __init__(self, parts):
-        self._parts = parts
+    def __init__(
+        self,
+        parts: List["Union[str, OptionalPart, FormattingPart]"]
+    ):
+        self._parts: List["Union[str, OptionalPart, FormattingPart]"] = parts
 
     @property
-    def parts(self):
+    def parts(self) -> List["Union[str, OptionalPart, FormattingPart]"]:
         return self._parts
 
-    def __str__(self):
+    def __str__(self) -> str:
         return "<{}>".format("".join([str(p) for p in self._parts]))
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return "<Optional:{}>".format("".join([str(p) for p in self._parts]))
 
-    def format(self, data, result):
+    def format(
+        self,
+        data: Dict[str, Any],
+        result: TemplatePartResult,
+    ) -> TemplatePartResult:
         new_result = TemplatePartResult(True)
         for part in self._parts:
             if isinstance(part, str):

From 04daa9306c3a0f5d70d24fa75fe936a415c6532f Mon Sep 17 00:00:00 2001
From: Jakub Trllo <43494761+iLLiCiTiT@users.noreply.github.com>
Date: Wed, 4 Dec 2024 16:14:59 +0100
Subject: [PATCH 8/8] remove unused import

---
 client/ayon_core/lib/path_templates.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/client/ayon_core/lib/path_templates.py b/client/ayon_core/lib/path_templates.py
index 3e66344ff4..e3cae78a87 100644
--- a/client/ayon_core/lib/path_templates.py
+++ b/client/ayon_core/lib/path_templates.py
@@ -5,7 +5,7 @@ import numbers
 import warnings
 from string import Formatter
 import typing
-from typing import List, Dict, Any, Set, Optional
+from typing import List, Dict, Any, Set
 
 if typing.TYPE_CHECKING:
     from typing import Union