change each __type__ in catalog to full qualified name, rather than snake of class name, and remove _class_register altogether

Signed-off-by: dafnapension <[email protected]>

Author: dafnapension

docs/catalog.py

@@ -50,8 +50,8 @@ def imports_to_syntax_highlighted_html(subtypes: List[str])-> str:
         return ""
     module_to_class_names = defaultdict(list)
     for subtype in subtypes:
-        subtype_class = Artifact._class_register.get(subtype)
-        module_to_class_names[subtype_class.__module__].append(subtype_class.__name__)
+        (module, class_name) = Artifact.get_module_class(subtype)
+        module_to_class_names[module].append(class_name)
 
     imports_txt = ""
     for modu in sorted(module_to_class_names.keys()):
@@ -101,31 +101,6 @@ def custom_walk(top):
             yield entry
 
 
-def all_subtypes_of_artifact(artifact):
-    if (
-        artifact is None
-        or isinstance(artifact, str)
-        or isinstance(artifact, bool)
-        or isinstance(artifact, int)
-        or isinstance(artifact, float)
-    ):
-        return []
-    if isinstance(artifact, list):
-        to_return = []
-        for art in artifact:
-            to_return.extend(all_subtypes_of_artifact(art))
-        return to_return
-    # artifact is a dict
-    to_return = []
-    for key, value in artifact.items():
-        if isinstance(value, str):
-            if key == "__type__":
-                to_return.append(value)
-        else:
-            to_return.extend(all_subtypes_of_artifact(value))
-    return to_return
-
-
 def get_all_type_elements(nested_dict):
     type_elements = set()
 
@@ -148,19 +123,18 @@ def recursive_search(d):
 
 @lru_cache(maxsize=None)
 def artifact_type_to_link(artifact_type):
-    artifact_class = Artifact._class_register.get(artifact_type)
-    type_class_name = artifact_class.__name__
-    artifact_class_id = f"{artifact_class.__module__}.{type_class_name}"
-    return f'<a class="reference internal" href="../{artifact_class.__module__}.html#{artifact_class_id}" title="{artifact_class_id}"><code class="xref py py-class docutils literal notranslate"><span class="pre">{type_class_name}</span></code></a>'
+    artifact_module, artifact_class_name = Artifact.get_module_class(artifact_type)
+    return f'<a class="reference internal" href="../{artifact_module}.html#{artifact_module}.{artifact_class_name}" title="{artifact_module}.{artifact_class_name}"><code class="xref py py-class docutils literal notranslate"><span class="pre">{artifact_class_name}</span></code></a>'
 
 
 # flake8: noqa: C901
+
+
 def make_content(artifact, label, all_labels):
-    artifact_type = artifact["__type__"]
-    artifact_class = Artifact._class_register.get(artifact_type)
-    type_class_name = artifact_class.__name__
-    catalog_id = label.replace("catalog.", "")
+    artifact_type = artifact["__type__"]    #qualified class name
+    artifact_class = Artifact.get_class_from_artifact_type(artifact_type)
 
+    catalog_id = label.replace("catalog.", "")
     result = ""
 
     if "__description__" in artifact and artifact["__description__"] is not None:
@@ -203,23 +177,16 @@ def make_content(artifact, label, all_labels):
         )
 
     for type_name in type_elements:
-        # source = f'<span class="nt">__type__</span><span class="p">:</span><span class="w"> </span><span class="l l-Scalar l-Scalar-Plain">{type_name}</span>'
-        source = f'<span class="n">__type__{type_name}</span><span class="p">'
-        target = artifact_type_to_link(type_name)
-        html_for_dict = html_for_dict.replace(
-            source,
-            f'<span class="n" STYLE="font-size:108%">{target}</span><span class="p">'
-            # '<span class="nt">&quot;type&quot;</span><span class="p">:</span><span class="w"> </span>'
-            # + target,
-        )
-
-    pattern = r'(<span class="nt">)&quot;(.*?)&quot;(</span>)'
+        artifact_module, artifact_class_name = Artifact.get_module_class(type_name)
+        pattern = re.compile(f'<span class="n">__type__(.*?)<span class="n">{artifact_class_name}</span>')
+        repl = '<span class="n" STYLE="font-size:108%">'+artifact_type_to_link(type_name)+"</span>"
+        html_for_dict = pattern.sub(repl, html_for_dict)
 
+    # pattern = r'(<span class="nt">)&quot;(.*?)&quot;(</span>)'
     # Replacement function
-    html_for_dict = re.sub(pattern, r"\1\2\3", html_for_dict)
+    # html_for_dict = re.sub(pattern, r"\1\2\3", html_for_dict)
 
-    subtypes = all_subtypes_of_artifact(artifact)
-    subtypes = list(set(subtypes))
+    subtypes = type_elements
     subtypes.remove(artifact_type)  # this was already documented
     html_for_imports = imports_to_syntax_highlighted_html(subtypes)
 
@@ -235,13 +202,13 @@ def make_content(artifact, label, all_labels):
     result += "    " + html_for_element + "\n"
 
     if artifact_class.__doc__:
-        explanation_str = f"Explanation about `{type_class_name}`"
+        explanation_str = f"Explanation about `{artifact_class.__name__}`"
         result += f"\n{explanation_str}\n"
         result += "+" * len(explanation_str) + "\n\n"
         result += artifact_class.__doc__ + "\n"
 
     for subtype in subtypes:
-        subtype_class = Artifact._class_register.get(subtype)
+        subtype_class = Artifact.get_class_from_artifact_type(subtype)
         subtype_class_name = subtype_class.__name__
         if subtype_class.__doc__:
             explanation_str = f"Explanation about `{subtype_class_name}`"

docs/conf.py

@@ -115,7 +115,6 @@ def autodoc_skip_member(app, what, name, obj, would_skip, options):
         class_name = obj.__qualname__.split(".")[0]
         if (
             class_name
-            and Artifact.is_registered_class_name(class_name)
             and class_name != name
         ):
             return True

prepare/metrics/custom_f1.py

@@ -433,4 +433,7 @@ class NERWithoutClassReporting(NER):
     global_target=global_target,
 )
 
-add_to_catalog(metric, "metrics.ner", overwrite=True)
+if __name__ == "__main__" or __name__ == "custom_f1":
+    # because a class is defined in this module, need to not add_to_catalog just for importing that module in order to retrieve the defined class
+    # and need to prepare for case when this module is run directly from python (__main__) or, for example, from test_preparation (custom_f1)
+    add_to_catalog(metric, "metrics.ner", overwrite=True)

src/unitxt/artifact.py

@@ -1,11 +1,11 @@
-import difflib
 import inspect
 import json
 import os
 import pkgutil
 import re
 import warnings
 from abc import abstractmethod
+from importlib import import_module
 from typing import Any, Dict, List, Optional, Tuple, Union, final
 
 from .dataclass import (
@@ -22,7 +22,7 @@
     separate_inside_and_outside_square_brackets,
 )
 from .settings_utils import get_constants, get_settings
-from .text_utils import camel_to_snake_case, is_camel_case, print_dict_as_yaml
+from .text_utils import print_dict_as_yaml
 from .type_utils import isoftype, issubtype
 from .utils import (
     artifacts_json_cache,
@@ -133,21 +133,11 @@ def maybe_recover_artifacts_structure(obj):
     return obj
 
 
-def get_closest_artifact_type(type):
-    artifact_type_options = list(Artifact._class_register.keys())
-    matches = difflib.get_close_matches(type, artifact_type_options)
-    if matches:
-        return matches[0]  # Return the closest match
-    return None
-
 
 class UnrecognizedArtifactTypeError(ValueError):
     def __init__(self, type) -> None:
-        maybe_class = "".join(word.capitalize() for word in type.split("_"))
+        maybe_class = type.split(".")[-1]
         message = f"'{type}' is not a recognized artifact 'type'. Make sure a the class defined this type (Probably called '{maybe_class}' or similar) is defined and/or imported anywhere in the code executed."
-        closest_artifact_type = get_closest_artifact_type(type)
-        if closest_artifact_type is not None:
-            message += f"\n\nDid you mean '{closest_artifact_type}'?"
         super().__init__(message)
 
 
@@ -160,7 +150,7 @@ def __init__(self, dic) -> None:
 
 
 class Artifact(Dataclass):
-    _class_register = {}
+    # _class_register = {}
 
     __type__: str = Field(default=None, final=True, init=False)
     __title__: str = NonPositionalField(
@@ -200,38 +190,60 @@ def verify_artifact_dict(cls, d):
             )
         if "__type__" not in d:
             raise MissingArtifactTypeError(d)
-        if not cls.is_registered_type(d["__type__"]):
-            raise UnrecognizedArtifactTypeError(d["__type__"])
+        # if not cls.is_registered_type(d["__type__"]):
+        #     raise UnrecognizedArtifactTypeError(d["__type__"])
+
+    @staticmethod
+    def fix_module_name_if_not_in_path(module):
+        module_name = getattr(module, "__name__", None)
+        if not module_name:
+            if getattr(module, "__file__", None):
+                return module.__file__.split(os.sep)[-1].split(".")[0]
+            return "dummy_module_name"
+        if not getattr(module, "__file__", None):
+            return module_name
+        name_components = module.__name__.split(".")
+        if all (name_component in module.__file__ for name_component in name_components):
+            return module_name
+        file_components = module.__file__.split(os.sep)
+        if file_components[0] == "":
+            file_components = file_components[1:]
+        file_components[-1] = file_components[-1].split(".")[0]  #omit the .py
+        if not getattr(module, "__package__", None) or len(module.__package__) == 0:
+            return file_components[-1]
+        package_components = module.__package__.split(".")
+        assert all(p_c in file_components for p_c in package_components)
+        for i in range(len(file_components)-len(package_components)+1):
+            if all(package_components[j] == file_components[i+j] for j in range(len(package_components))):
+                if i==len(file_components)-len(package_components):
+                    return module.__package__
+                return module.__package__ +"."+ (".".join(file_components[i+len(package_components):]))
+        return "dummy_module_name"
 
     @classmethod
     def get_artifact_type(cls):
-        return camel_to_snake_case(cls.__name__)
+        module = inspect.getmodule(cls)
+        # standardize module name
+        module_name = getattr(module, "__name__", None)
+        module_package = getattr(module, "__package__", None)
+        module_name = Artifact.fix_module_name_if_not_in_path(module)
+        if module_package:
+            if not module_name.startswith(module_package):
+                module_name = module_package+"."+module_name
+        if hasattr(cls, "__qualname__") and "." in cls.__qualname__:
+            return module_name+"/"+cls.__qualname__
+        return module_name+"."+cls.__name__
 
     @classmethod
-    def register_class(cls, artifact_class):
-        assert issubclass(
-            artifact_class, Artifact
-        ), f"Artifact class must be a subclass of Artifact, got '{artifact_class}'"
-        assert is_camel_case(
-            artifact_class.__name__
-        ), f"Artifact class name must be legal camel case, got '{artifact_class.__name__}'"
-
-        snake_case_key = camel_to_snake_case(artifact_class.__name__)
-
-        if cls.is_registered_type(snake_case_key):
-            assert (
-                str(cls._class_register[snake_case_key]) == str(artifact_class)
-            ), f"Artifact class name must be unique, '{snake_case_key}' already exists for {cls._class_register[snake_case_key]}. Cannot be overridden by {artifact_class}."
-
-            return snake_case_key
+    def get_module_class(cls, artifact_type:str):
+        if "/" in artifact_type:
+            return artifact_type.split("/")
+        return artifact_type.rsplit(".", 1)
 
-        cls._class_register[snake_case_key] = artifact_class
 
-        return snake_case_key
 
     def __init_subclass__(cls, **kwargs):
         super().__init_subclass__(**kwargs)
-        cls.register_class(cls)
 
     @classmethod
     def is_artifact_file(cls, path):
@@ -242,34 +254,32 @@ def is_artifact_file(cls, path):
         return cls.is_artifact_dict(d)
 
     @classmethod
-    def is_registered_type(cls, type: str):
-        return type in cls._class_register
+    def get_class_from_artifact_type(cls, type:str):
+        module_path, class_name = cls.get_module_class(type)
+        module = import_module(module_path)
+        if "." not in class_name:
+            return getattr(module, class_name)
+        class_name_components = class_name.split(".")
+        klass = getattr(module, class_name_components[0])
+        for i in range (1, len(class_name_components)):
+            klass = getattr(klass, class_name_components[i])
+        return klass
 
-    @classmethod
-    def is_registered_class_name(cls, class_name: str):
-        snake_case_key = camel_to_snake_case(class_name)
-        return cls.is_registered_type(snake_case_key)
-
-    @classmethod
-    def is_registered_class(cls, clz: object):
-        return clz in set(cls._class_register.values())
 
     @classmethod
     def _recursive_load(cls, obj):
         if isinstance(obj, dict):
-            new_d = {}
-            for key, value in obj.items():
-                new_d[key] = cls._recursive_load(value)
-            obj = new_d
+            obj = {key: cls._recursive_load(value) for key, value in obj.items()}
+            if cls.is_artifact_dict(obj):
+                try:
+                    artifact_type = obj.pop("__type__")
+                    artifact_class = cls.get_class_from_artifact_type(artifact_type)
+                    obj = artifact_class.process_data_after_load(obj)
+                    return artifact_class(**obj)
+                except (ImportError, AttributeError) as e:
+                    raise UnrecognizedArtifactTypeError(artifact_type) from e
         elif isinstance(obj, list):
-            obj = [cls._recursive_load(value) for value in obj]
-        else:
-            pass
-        if cls.is_artifact_dict(obj):
-            cls.verify_artifact_dict(obj)
-            artifact_class = cls._class_register[obj.pop("__type__")]
-            obj = artifact_class.process_data_after_load(obj)
-            return artifact_class(**obj)
+            return [cls._recursive_load(value) for value in obj]
 
         return obj
 
@@ -283,7 +293,7 @@ def from_dict(cls, d, overwrite_args=None):
     @classmethod
     def load(cls, path, artifact_identifier=None, overwrite_args=None):
         d = artifacts_json_cache(path)
-        if "__type__" in d and d["__type__"] == "artifact_link":
+        if "__type__" in d and d["__type__"].endswith("ArtifactLink"):
             cls.from_dict(d)  # for verifications and warnings
             catalog, artifact_rep, _ = get_catalog_name_and_args(name=d["to"])
             return catalog.get_with_overwrite(
@@ -329,7 +339,7 @@ def verify_data_classification_policy(self):
 
     @final
     def __post_init__(self):
-        self.__type__ = self.register_class(self.__class__)
+        self.__type__ = self.__class__.get_artifact_type()
 
         for field in fields(self):
             if issubtype(
@@ -347,14 +357,18 @@ def __post_init__(self):
 
     def _to_raw_dict(self):
         return {
-            "__type__": self.__type__,
+            "__type__": self.__class__.get_artifact_type(),
             **self.process_data_before_dump(self._init_dict),
         }
 
     def __deepcopy__(self, memo):
         if id(self) in memo:
             return memo[id(self)]
-        new_obj = Artifact.from_dict(self.to_dict())
+        try:
+            new_obj = Artifact.from_dict(self.to_dict())
+        except:
+            # needed only for artifacts defined inline for testing etc. E.g. 'NERWithoutClassReporting'
+            new_obj = self
         memo[id(self)] = new_obj
         return new_obj
 

src/unitxt/catalog/augmentors/augment_whitespace_prefix_and_suffix_task_input.json

@@ -1,5 +1,5 @@
 {
-    "__type__": "artifact_link",
+    "__type__": "unitxt.artifact.ArtifactLink",
     "to": "augmentors.text.whitespace_prefix_suffix",
     "__deprecated_msg__": "Artifact 'augmentors.augment_whitespace_prefix_and_suffix_task_input' is deprecated. Artifact 'augmentors.text.whitespace_prefix_suffix' will be instantiated instead. In future uses, please reference artifact 'augmentors.text.whitespace_prefix_suffix' directly."
 }

src/unitxt/catalog/augmentors/augment_whitespace_task_input.json

@@ -1,5 +1,5 @@
 {
-    "__type__": "artifact_link",
+    "__type__": "unitxt.artifact.ArtifactLink",
     "to": "augmentors.text.whitespace_prefix_suffix",
     "__deprecated_msg__": "Artifact 'augmentors.augment_whitespace_task_input' is deprecated. Artifact 'augmentors.text.whitespace_prefix_suffix' will be instantiated instead. In future uses, please reference artifact 'augmentors.text.whitespace_prefix_suffix' directly."
 }

src/unitxt/catalog/augmentors/image/grey_scale.json

@@ -1,3 +1,3 @@
 {
-    "__type__": "gray_scale"
+    "__type__": "unitxt.image_operators.GrayScale"
 }

src/unitxt/catalog/augmentors/image/grid_lines.json

@@ -1,3 +1,3 @@
 {
-    "__type__": "grid_lines"
+    "__type__": "unitxt.image_operators.GridLines"
 }

src/unitxt/catalog/augmentors/image/oldify.json

@@ -1,3 +1,3 @@
 {
-    "__type__": "oldify"
+    "__type__": "unitxt.image_operators.Oldify"
 }

src/unitxt/catalog/augmentors/image/white_noise.json

@@ -1,3 +1,3 @@
 {
-    "__type__": "pixel_noise"
+    "__type__": "unitxt.image_operators.PixelNoise"
 }