prepare for backward compatibility

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

Author: dafnapension

src/unitxt/artifact.py

@@ -3,6 +3,7 @@
 import json
 import os
 import re
+import subprocess
 import sys
 import sysconfig
 import warnings
@@ -24,6 +25,7 @@
     separate_inside_and_outside_square_brackets,
 )
 from .settings_utils import get_constants, get_settings
+from .text_utils import snake_to_camel_case
 from .type_utils import isoftype, issubtype
 from .utils import (
     artifacts_json_cache,
@@ -227,9 +229,25 @@ def get_module_class_names(artifact_type: dict):
     return artifact_type["module"], artifact_type["name"]
 
 
+def convert_str_type_to_dict(type: str) -> dict:
+    class_name = snake_to_camel_case(type)
+    return {
+        "module": find_unitxt_module_by_classname(camel_case_class_name=class_name),
+        "name": class_name,
+    }
+
+
 # type is the dict read from a catelog entry, the value of a key "__type__"
 def get_class_from_artifact_type(type: dict):
-    module_path, class_name = get_module_class_names(type)
+    if isinstance(type, str):
+        if type in Artifact._class_register:
+            return Artifact._class_register[type]
+
+        class_name = snake_to_camel_case(type)
+        module_path = find_unitxt_module_by_classname(camel_case_class_name=class_name)
+    else:
+        module_path, class_name = get_module_class_names(type)
+
     if module_path == "class_register":
         if class_name not in Artifact._class_register:
             raise ValueError(
@@ -487,12 +505,15 @@ def is_artifact_file(cls, path):
     @classmethod
     def load(cls, path, artifact_identifier=None, overwrite_args=None):
         d = artifacts_json_cache(path)
-        if "__type__" in d and d["__type__"]["name"].endswith("ArtifactLink"):
-            from_dict(d)  # for verifications and warnings
-            catalog, artifact_rep, _ = get_catalog_name_and_args(name=d["to"])
-            return catalog.get_with_overwrite(
-                artifact_rep, overwrite_args=overwrite_args
-            )
+        if "__type__" in d:
+            if isinstance(d["__type__"], str):
+                d["__type__"] = convert_str_type_to_dict(d["__type__"])
+            if d["__type__"]["name"].endswith("ArtifactLink"):
+                from_dict(d)  # for verifications and warnings
+                catalog, artifact_rep, _ = get_catalog_name_and_args(name=d["to"])
+                return catalog.get_with_overwrite(
+                    artifact_rep, overwrite_args=overwrite_args
+                )
 
         new_artifact = from_dict(d, overwrite_args=overwrite_args)
         new_artifact.__id__ = artifact_identifier
@@ -898,3 +919,22 @@ def get_artifacts_data_classification(artifact: str) -> Optional[List[str]]:
         return None
 
     return data_classification.get(artifact)
+
+
+def find_unitxt_module_by_classname(camel_case_class_name: str):
+    """Find a module, a member of src/unitxt, that contains the definition of the class."""
+    dir = os.path.dirname(__file__)  # dir  src/unitxt
+    try:
+        result = subprocess.run(
+            ["grep", "-lrwE", "^class +" + camel_case_class_name, dir],
+            capture_output=True,
+        ).stdout.decode("ascii")
+        results = result.split("\n")
+        assert len(results) == 2, f"returned: {results}"
+        assert results[-1] == "", f"last result is {results[-1]} rather than ''"
+        to_return = results[0][:-3].replace("/", ".")  # trim the .py and replace
+        return to_return[to_return.rfind("unitxt.") :]
+    except Exception as e:
+        raise ValueError(
+            f"Could not find the unitxt module, under unitxt/src/unitxt, in which class {camel_case_class_name} is defined"
+        ) from e

src/unitxt/text_utils.py

@@ -71,6 +71,58 @@ def camel_to_snake_case(s):
     return s.lower()
 
 
+def snake_to_camel_case(s):
+    """Converts a snake_case string s to CamelCase. Assume a class name is in question so result to start with an upper case."""
+    s = s.strip()
+    words = s.split("_")
+    # Capitalize all words and join them
+    camel_case_parts = [word.capitalize() for word in words]
+    final_fixes = {
+        "LoadHf": "LoadHF",
+        "LoadCsv": "LoadCSV",
+        "LoadFromHfSpace": "LoadFromHFSpace",
+        "LoadIob": "LoadIOB",
+        "AddId": "AddID",
+        "Anls": "ANLS",
+        "AzureOpenAiInferenceEngine": "AzureOpenAIInferenceEngine",
+        "ChatApiFormat": "ChatAPIFormat",
+        "ExactMatchMm": "ExactMatchMM",
+        "FaithfulnessHhem": "FaithfulnessHHEM",
+        "FinQaEval": "FinQAEval",
+        "FixedGroupPdrParaphraseAccuracy": "FixedGroupPDRParaphraseAccuracy",
+        "FixedGroupPdrParaphraseStringContainment": "FixedGroupPDRParaphraseStringContainment",
+        "GetSql": "GetSQL",
+        "HfPipelineBasedInferenceEngine": "HFPipelineBasedInferenceEngine",
+        "HfSystemFormat": "HFSystemFormat",
+        "Kpa": "KPA",
+        "LlmAsJudge": "LLMAsJudge",
+        "LlmJudgeDirect": "LLMJudgeDirect",
+        "LlmJudgePairwise": "LLMJudgePairwise",
+        "Map": "MAP",
+        "MapHtmlTableToJson": "MapHTMLTableToJSON",
+        "MapTableListsToStdTableJson": "MapTableListsToStdTableJSON",
+        "Mrr": "MRR",
+        "Ndcg": "NDCG",
+        "Ner": "NER",
+        "ParseCsv": "ParseCSV",
+        "RitsInferenceEngine": "RITSInferenceEngine",
+        "SerializeTableAsDfLoader": "SerializeTableAsDFLoader",
+        "SerializeTableAsHtml": "SerializeTableAsHTML",
+        "SqlDatabaseAsSchemaSerializer": "SQLDatabaseAsSchemaSerializer",
+        "SqlExecutionAccuracy": "SQLExecutionAccuracy",
+        "SqlNonExecutionAccuracy": "SQLNonExecutionAccuracy",
+        "TaskBasedLlMasJudge": "TaskBasedLLMasJudge",
+        "ToRgb": "ToRGB",
+        "TurlColumnTypeAnnotationLoader": "TURLColumnTypeAnnotationLoader",
+        "WmlInferenceEngine": "WMLInferenceEngine",
+        "WmlInferenceEngineGeneration": "WMLInferenceEngineGeneration",
+    }
+    to_return = "".join(camel_case_parts)
+    if to_return in final_fixes:
+        return final_fixes[to_return]
+    return to_return
+
+
 def to_pretty_string(
     value,
     indent=0,