Upload folder using huggingface_hub

README.md

@@ -2,11 +2,11 @@
     <img src="https://raw.githubusercontent.com/IBM/unitxt/main/assets/banner.png" alt="Image Description" width="100%" />
 </div>
 
-[![Button](https://img.shields.io/badge/Video-pink?style=for-the-badge)](https://unitxt.readthedocs.io/)
+[![Button](https://img.shields.io/badge/Video-pink?style=for-the-badge)](https://unitxt.readthedocs.io/en/latest/_static/video.mov)
+[![Button](https://img.shields.io/badge/Documentation-pink?style=for-the-badge)](https://unitxt.readthedocs.io/en/latest/docs/introduction.html)
 [![Button](https://img.shields.io/badge/Demo-pink?style=for-the-badge)](https://unitxt.readthedocs.io/en/latest/docs/demo.html)
 [![Button](https://img.shields.io/badge/Tutorial-pink?style=for-the-badge)](https://unitxt.readthedocs.io/en/latest/docs/adding_dataset.html)
 [![Button](https://img.shields.io/badge/Paper-pink?style=for-the-badge)](https://arxiv.org/abs/2401.14019)
-[![Button](https://img.shields.io/badge/Documentation-pink?style=for-the-badge)](https://unitxt.readthedocs.io/en/latest/modules.html)
 [![Button](https://img.shields.io/badge/Catalog-pink?style=for-the-badge)](https://unitxt.readthedocs.io/en/latest/catalog/catalog.__dir__.html)
 [![Button](https://img.shields.io/badge/Contributors-pink?style=for-the-badge)](https://github.com/IBM/unitxt/blob/main/CONTRIBUTING.md)
 [![Button](https://img.shields.io/badge/PyPi-pink?style=for-the-badge)](https://pypi.org/project/unitxt/)
@@ -63,13 +63,32 @@ pre-commit install
 If you use Unitxt in your research, please cite our paper:
 
 ```
-@misc{unitxt,
-      title={Unitxt: Flexible, Shareable and Reusable Data Preparation and Evaluation for Generative AI},
-      author={Elron Bandel and Yotam Perlitz and Elad Venezian and Roni Friedman-Melamed and Ofir Arviv and Matan Orbach and Shachar Don-Yehyia and Dafna Sheinwald and Ariel Gera and Leshem Choshen and Michal Shmueli-Scheuer and Yoav Katz},
-      year={2024},
-      eprint={2401.14019},
-      archivePrefix={arXiv},
-      primaryClass={cs.CL}
+@inproceedings{bandel-etal-2024-unitxt,
+    title = "Unitxt: Flexible, Shareable and Reusable Data Preparation and Evaluation for Generative {AI}",
+    author = "Bandel, Elron  and
+      Perlitz, Yotam  and
+      Venezian, Elad  and
+      Friedman, Roni  and
+      Arviv, Ofir  and
+      Orbach, Matan  and
+      Don-Yehiya, Shachar  and
+      Sheinwald, Dafna  and
+      Gera, Ariel  and
+      Choshen, Leshem  and
+      Shmueli-Scheuer, Michal  and
+      Katz, Yoav",
+    editor = "Chang, Kai-Wei  and
+      Lee, Annie  and
+      Rajani, Nazneen",
+    booktitle = "Proceedings of the 2024 Conference of the North American Chapter of the Association for Computational Linguistics: Human Language Technologies (Volume 3: System Demonstrations)",
+    month = jun,
+    year = "2024",
+    address = "Mexico City, Mexico",
+    publisher = "Association for Computational Linguistics",
+    url = "https://aclanthology.org/2024.naacl-demo.21",
+    pages = "207--215",
+    abstract = "In the dynamic landscape of generative NLP, traditional text processing pipelines limit research flexibility and reproducibility, as they are tailored to specific dataset, task, and model combinations. The escalating complexity, involving system prompts, model-specific formats, instructions, and more, calls for a shift to a structured, modular, and customizable solution.Addressing this need, we present Unitxt, an innovative library for customizable textual data preparation and evaluation tailored to generative language models. Unitxt natively integrates with common libraries like HuggingFace and LM-eval-harness and deconstructs processing flows into modular components, enabling easy customization and sharing between practitioners. These components encompass model-specific formats, task prompts, and many other comprehensive dataset processing definitions. The Unitxt Catalog centralizes these components, fostering collaboration and exploration in modern textual data workflows. Beyond being a tool, Unitxt is a community-driven platform, empowering users to build, share, and advance their pipelines collaboratively. Join the Unitxt community at https://github.com/IBM/unitxt",
 }
 ```
 
+Unitxt emoji designed by [OpenMoji](https://openmoji.org/#) - the open-source emoji and icon project. License: [CC BY-SA 4.0](https://creativecommons.org/licenses/by-sa/4.0/#)

api.py

@@ -1,13 +1,14 @@
 from functools import lru_cache
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List, Optional, Union
 
 from datasets import DatasetDict
 
 from .artifact import fetch_artifact
 from .dataset_utils import get_dataset_artifact
 from .logging_utils import get_logger
-from .metric_utils import _compute
+from .metric_utils import _compute, _post_process
 from .operator import SourceOperator
+from .standard import StandardRecipe
 
 logger = get_logger()
 
@@ -21,16 +22,79 @@ def load(source: Union[SourceOperator, str]) -> DatasetDict:
     return source().to_dataset()
 
 
-def load_dataset(dataset_query: str) -> DatasetDict:
+def _load_dataset_from_query(dataset_query: str) -> DatasetDict:
     dataset_query = dataset_query.replace("sys_prompt", "instruction")
     dataset_stream = get_dataset_artifact(dataset_query)
     return dataset_stream().to_dataset()
 
 
+def _load_dataset_from_dict(dataset_params: Dict[str, Any]) -> DatasetDict:
+    recipe_attributes = list(StandardRecipe.__dict__["__fields__"].keys())
+    for param in dataset_params.keys():
+        assert param in recipe_attributes, (
+            f"The parameter '{param}' is not an attribute of the 'StandardRecipe' class. "
+            f"Please check if the name is correct. The available attributes are: '{recipe_attributes}'."
+        )
+    recipe = StandardRecipe(**dataset_params)
+    return recipe().to_dataset()
+
+
+def load_dataset(dataset_query: Optional[str] = None, **kwargs) -> DatasetDict:
+    """Loads dataset.
+
+    If the 'dataset_query' argument is provided, then dataset is loaded from a card in local
+    catalog based on parameters specified in the query.
+    Alternatively, dataset is loaded from a provided card based on explicitly given parameters.
+
+    Args:
+        dataset_query (str, optional): A string query which specifies dataset to load from local catalog.
+            For example:
+            "card=cards.wnli,template=templates.classification.multi_class.relation.default".
+        **kwargs: Arguments used to load dataset from provided card, which is not present in local catalog.
+
+    Returns:
+        DatasetDict
+
+    Examples:
+        dataset = load_dataset(
+            dataset_query="card=cards.stsb,template=templates.regression.two_texts.simple,max_train_instances=5"
+        )  # card must be present in local catalog
+
+        card = TaskCard(...)
+        template = Template(...)
+        loader_limit = 10
+        dataset = load_dataset(card=card, template=template, loader_limit=loader_limit)
+    """
+    if dataset_query and kwargs:
+        raise ValueError(
+            "Cannot provide 'dataset_query' and key-worded arguments at the same time. "
+            "If you want to load dataset from a card in local catalog, use query only. "
+            "Otherwise, use key-worded arguments only to specify properties of dataset."
+        )
+
+    if dataset_query:
+        if not isinstance(dataset_query, str):
+            raise ValueError(
+                f"If specified, 'dataset_query' must be a string, however, "
+                f"'{dataset_query}' was provided instead, which is of type "
+                f"'{type(dataset_query)}'."
+            )
+        return _load_dataset_from_query(dataset_query)
+
+    if kwargs:
+        return _load_dataset_from_dict(kwargs)
+
+    raise ValueError("Either 'dataset_query' or key-worded arguments must be provided.")
+
+
 def evaluate(predictions, data) -> List[Dict[str, Any]]:
     return _compute(predictions=predictions, references=data)
 
 
+def post_process(predictions, data) -> List[Dict[str, Any]]:
+    return _post_process(predictions=predictions, references=data)
+
+
 @lru_cache
 def _get_produce_with_cache(recipe_query):
     return get_dataset_artifact(recipe_query).produce
@@ -44,3 +108,10 @@ def produce(instance_or_instances, recipe_query):
     if not is_list:
         result = result[0]
     return result
+
+
+def infer(instance_or_instances, recipe, engine):
+    dataset = produce(instance_or_instances, recipe)
+    engine, _ = fetch_artifact(engine)
+    predictions = engine.infer(dataset)
+    return post_process(predictions, dataset)

artifact.py

@@ -3,9 +3,10 @@ import inspect
 import json
 import os
 import pkgutil
+import re
 from abc import abstractmethod
 from copy import deepcopy
-from typing import Any, Dict, List, Optional, Union, final
+from typing import Any, Dict, List, Optional, Tuple, Union, final
 
 from .dataclass import (
     AbstractField,
@@ -19,13 +20,24 @@ from .logging_utils import get_logger
 from .parsing_utils import (
     separate_inside_and_outside_square_brackets,
 )
-from .settings_utils import get_settings
+from .settings_utils import get_constants, get_settings
 from .text_utils import camel_to_snake_case, is_camel_case
 from .type_utils import issubtype
-from .utils import artifacts_json_cache, save_json
+from .utils import artifacts_json_cache, json_dump, save_to_file
 
 logger = get_logger()
 settings = get_settings()
+constants = get_constants()
+
+
+def is_name_legal_for_catalog(name):
+    return re.match(r"^[\w" + constants.catalog_hierarchy_sep + "]+$", name)
+
+
+def verify_legal_catalog_name(name):
+    assert is_name_legal_for_catalog(
+        name
+    ), f'Artifict name ("{name}") should be alphanumeric. Use "." for nesting (e.g. myfolder.my_artifact)'
 
 
 class Artifactories:
@@ -120,7 +132,7 @@ class MissingArtifactTypeError(ValueError):
 class Artifact(Dataclass):
     _class_register = {}
 
-    type: str = Field(default=None, final=True, init=False)
+    __type__: str = Field(default=None, final=True, init=False)
     __description__: str = NonPositionalField(
         default=None, required=False, also_positional=False
     )
@@ -135,7 +147,7 @@ class Artifact(Dataclass):
 
     @classmethod
     def is_artifact_dict(cls, d):
-        return isinstance(d, dict) and "type" in d
+        return isinstance(d, dict) and "__type__" in d
 
     @classmethod
     def verify_artifact_dict(cls, d):
@@ -143,10 +155,10 @@ class Artifact(Dataclass):
             raise ValueError(
                 f"Artifact dict <{d}> must be of type 'dict', got '{type(d)}'."
             )
-        if "type" not in 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__"])
 
     @classmethod
     def get_artifact_type(cls):
@@ -212,7 +224,7 @@ class Artifact(Dataclass):
             pass
         if cls.is_artifact_dict(obj):
             cls.verify_artifact_dict(obj)
-            return cls._class_register[obj.pop("type")](**obj)
+            return cls._class_register[obj.pop("__type__")](**obj)
 
         return obj
 
@@ -261,7 +273,7 @@ class Artifact(Dataclass):
 
     @final
     def __post_init__(self):
-        self.type = self.register_class(self.__class__)
+        self.__type__ = self.register_class(self.__class__)
 
         for field in fields(self):
             if issubtype(
@@ -277,11 +289,24 @@ class Artifact(Dataclass):
             self.verify()
 
     def _to_raw_dict(self):
-        return {"type": self.type, **self._init_dict}
+        return {"__type__": self.__type__, **self._init_dict}
 
-    def save(self, path):
+    def to_json(self):
         data = self.to_dict()
-        save_json(path, data)
+        return json_dump(data)
+
+    def serialize(self):
+        if self.__id__ is not None:
+            return self.__id__
+        return self.to_json()
+
+    def save(self, path):
+        save_to_file(path, self.to_json())
+
+    @classmethod
+    def deserialize(cls, artifact_rep):
+        data = json.loads(artifact_rep)
+        return Artifact.from_dict(data)
 
     def verify_instance(
         self, instance: Dict[str, Any], name: Optional[str] = None
@@ -404,13 +429,22 @@ class UnitxtArtifactNotFoundError(Exception):
         return f"Artifact {self.name} does not exist, in artifactories:{self.artifactories}"
 
 
-def fetch_artifact(name):
-    if Artifact.is_artifact_file(name):
-        return Artifact.load(name), None
+def fetch_artifact(artifact_rep) -> Tuple[Artifact, Union[Artifactory, None]]:
+    if isinstance(artifact_rep, Artifact):
+        return artifact_rep, None
+    if Artifact.is_artifact_file(artifact_rep):
+        return Artifact.load(artifact_rep), None
 
-    artifactory, name, args = get_artifactory_name_and_args(name=name)
+    name, _ = separate_inside_and_outside_square_brackets(artifact_rep)
+    if is_name_legal_for_catalog(name):
+        artifactory, artifact_rep, args = get_artifactory_name_and_args(
+            name=artifact_rep
+        )
+        return artifactory.get_with_overwrite(
+            artifact_rep, overwrite_args=args
+        ), artifactory
 
-    return artifactory.get_with_overwrite(name, overwrite_args=args), artifactory
+    return Artifact.deserialize(artifact_rep), None
 
 
 def get_artifactory_name_and_args(

blocks.py

@@ -8,13 +8,13 @@ from .loaders import LoadFromIBMCloud, LoadFromKaggle, LoadHF
 from .metrics import Accuracy
 from .normalizers import NormalizeListFields
 from .operators import (
-    AddFields,
     AddID,
     CastFields,
-    CopyFields,
+    Copy,
     DivideAllFieldsBy,
     MapInstanceValues,
     RenameFields,
+    Set,
 )
 from .processors import ToString, ToStringStripped
 from .recipe import SequentialRecipe

catalog.py

@@ -1,5 +1,4 @@
 import os
-import re
 from collections import Counter
 from functools import lru_cache
 from pathlib import Path
@@ -13,6 +12,7 @@ from .artifact import (
     Artifactory,
     get_artifactory_name_and_args,
     reset_artifacts_json_cache,
+    verify_legal_catalog_name,
 )
 from .logging_utils import get_logger
 from .settings_utils import get_constants
@@ -114,12 +114,6 @@ class GithubCatalog(LocalCatalog):
         return response.status_code == 200
 
 
-def verify_legal_catalog_name(name):
-    assert re.match(
-        r"^[\w" + constants.catalog_hierarchy_sep + "]+$", name
-    ), f'Artifict name ("{name}") should be alphanumeric. Use "." for nesting (e.g. myfolder.my_artifact)'
-
-
 def add_to_catalog(
     artifact: Artifact,
     name: str,

data.py

@@ -10,6 +10,7 @@ from .catalog import __file__ as _
 from .collections import __file__ as _
 from .collections_operators import __file__ as _
 from .dataclass import __file__ as _
+from .dataset_utils import __file__ as _
 from .dataset_utils import get_dataset_artifact
 from .deprecation_utils import __file__ as _
 from .dialog_operators import __file__ as _
@@ -19,11 +20,13 @@ from .file_utils import __file__ as _
 from .formats import __file__ as _
 from .fusion import __file__ as _
 from .generator_utils import __file__ as _
+from .hf_utils import __file__ as _
 from .hf_utils import verify_versions_compatibility
 from .inference import __file__ as _
 from .instructions import __file__ as _
 from .llm_as_judge import __file__ as _
 from .loaders import __file__ as _
+from .logging_utils import __file__ as _
 from .logging_utils import get_logger
 from .metric import __file__ as _
 from .metric_utils import __file__ as _
@@ -37,6 +40,7 @@ from .random_utils import __file__ as _
 from .recipe import __file__ as _
 from .register import __file__ as _
 from .schema import __file__ as _
+from .settings_utils import __file__ as _
 from .settings_utils import get_constants
 from .span_lableing_operators import __file__ as _
 from .split_utils import __file__ as _
@@ -51,6 +55,7 @@ from .task import __file__ as _
 from .templates import __file__ as _
 from .text_utils import __file__ as _
 from .type_utils import __file__ as _
+from .utils import __file__ as _
 from .utils import is_package_installed
 from .validate import __file__ as _
 from .version import __file__ as _
@@ -71,9 +76,8 @@ class Dataset(datasets.GeneratorBasedBuilder):
             if is_package_installed("unitxt"):
                 verify_versions_compatibility("dataset", self.VERSION)
 
-                from unitxt.dataset_utils import (
-                    get_dataset_artifact as get_dataset_artifact_installed,
-                )
+                from unitxt.dataset_utils import \
+                    get_dataset_artifact as get_dataset_artifact_installed
 
                 logger.info("Loading with installed unitxt library...")
                 dataset = get_dataset_artifact_installed(self.config.name)

dataset_utils.py

@@ -1,8 +1,11 @@
+from json.decoder import JSONDecodeError
+
 from .artifact import Artifact, UnitxtArtifactNotFoundError, fetch_artifact
 from .logging_utils import get_logger
 from .parsing_utils import parse_key_equals_value_string_to_dict
 from .register import _reset_env_local_catalogs, register_all_artifacts
 from .settings_utils import get_settings
+from .standard import BaseRecipe
 
 logger = get_logger()
 settings = get_settings()
@@ -12,7 +15,7 @@ def fetch(artifact_name):
     try:
         artifact, _ = fetch_artifact(artifact_name)
         return artifact
-    except UnitxtArtifactNotFoundError:
+    except (UnitxtArtifactNotFoundError, JSONDecodeError):
         return None
 
 
@@ -20,13 +23,18 @@ def parse(query: str):
     return parse_key_equals_value_string_to_dict(query)
 
 
-def get_dataset_artifact(dataset_str):
+def get_dataset_artifact(dataset):
+    if isinstance(dataset, BaseRecipe):
+        return dataset
+    assert isinstance(
+        dataset, str
+    ), "dataset should be string description of recipe, or recipe object."
     _reset_env_local_catalogs()
     register_all_artifacts()
-    recipe = fetch(dataset_str)
+    recipe = fetch(dataset)
     if recipe is None:
-        args = parse(dataset_str)
-        if "type" not in args:
-            args["type"] = settings.default_recipe
+        args = parse(dataset)
+        if "__type__" not in args:
+            args["__type__"] = settings.default_recipe
         recipe = Artifact.from_dict(args)
     return recipe

deprecation_utils.py

@@ -1,9 +1,10 @@
 import functools
 import warnings
 
-from .settings_utils import get_constants
+from .settings_utils import get_constants, get_settings
 
 constants = get_constants()
+settings = get_settings()
 
 
 class DeprecationError(Exception):
@@ -60,9 +61,12 @@ def depraction_wrapper(obj, version, alt_text):
     @functools.wraps(obj)
     def wrapper(*args, **kwargs):
         if constants.version < version:
-            warnings.warn(
-                f"{obj.__name__} is deprecated.", DeprecationWarning, stacklevel=2
-            )
+            if settings.default_verbosity in ["debug", "info", "warning"]:
+                warnings.warn(
+                    f"{obj.__name__} is deprecated.{alt_text}",
+                    DeprecationWarning,
+                    stacklevel=2,
+                )
         elif constants.version >= version:
             raise DeprecationError(f"{obj.__name__} is no longer supported.{alt_text}")
         return obj(*args, **kwargs)
@@ -82,7 +86,7 @@ def deprecation(version, alternative=None):
     """
 
     def decorator(obj):
-        alt_text = f" Use {alternative} instead." if alternative else ""
+        alt_text = f" Use {alternative} instead." if alternative is not None else ""
         if callable(obj):
             func = obj
         elif hasattr(obj, "__init__"):

dialog_operators.py

@@ -11,6 +11,7 @@ dialog = [
     {"user": "kkk", "system": ""},
 ]
 """
+
 from typing import Any, Dict, List, Optional
 
 from .formats import SystemFormat

fusion.py

@@ -103,9 +103,10 @@ class WeightedFusion(BaseFusion):
             If None, all instances are returned
     """
 
-    origins: Union[Dict[str, MultiStream], List[MultiStream]] = None
+    origins: Union[Dict[str, SourceOperator], List[SourceOperator]] = None
     weights: Union[Dict[str, Union[float, int]], List[Union[int, float]]] = None
     max_total_examples: int = None
+    ignore_origin_groups: List[str] = ["unitxt"]
 
     def verify(self):
         super().verify()
@@ -149,7 +150,10 @@ class WeightedFusion(BaseFusion):
             try:
                 instance = next(iterator)
                 if isinstance(origin_name, str):
-                    if "group" in instance:
+                    if (
+                        "group" in instance
+                        and instance["group"] not in self.ignore_origin_groups
+                    ):
                         instance["group"] = origin_name + "/" + instance["group"]
                     else:
                         instance["group"] = origin_name

inference.py

@@ -3,6 +3,8 @@ import os
 from dataclasses import field
 from typing import Any, Dict, List, Literal, Optional, Union
 
+from tqdm import tqdm
+
 from .artifact import Artifact
 from .operator import PackageRequirementsMixin
 
@@ -15,12 +17,31 @@ class InferenceEngine(abc.ABC, Artifact):
         """Perform inference on the input dataset."""
         pass
 
-    def infer(self, dataset):
+    def infer(self, dataset) -> str:
         """Verifies instances of a dataset and performs inference."""
         [self.verify_instance(instance) for instance in dataset]
         return self._infer(dataset)
 
 
+class LogProbInferenceEngine(abc.ABC, Artifact):
+    """Abstract base class for inference with log probs."""
+
+    @abc.abstractmethod
+    def _infer_log_probs(self, dataset):
+        """Perform inference on the input dataset that returns log probs."""
+        pass
+
+    def infer_log_probs(self, dataset) -> List[Dict]:
+        """Verifies instances of a dataset and performs inference that returns log probabilities of top tokens.
+
+        For each instance , returns a list of top tokens per position.
+        [ "top_tokens": [ { "text": ..., "logprob": ...} , ... ]
+
+        """
+        [self.verify_instance(instance) for instance in dataset]
+        return self._infer_log_probs(dataset)
+
+
 class HFPipelineBasedInferenceEngine(InferenceEngine, PackageRequirementsMixin):
     model_name: str
     max_new_tokens: int
@@ -158,9 +179,12 @@ class OpenAiInferenceEngineParams(Artifact):
     stop: Union[Optional[str], List[str]] = None
     temperature: Optional[float] = None
     top_p: Optional[float] = None
+    top_logprobs: Optional[int] = 20
 
 
-class OpenAiInferenceEngine(InferenceEngine, PackageRequirementsMixin):
+class OpenAiInferenceEngine(
+    InferenceEngine, LogProbInferenceEngine, PackageRequirementsMixin
+):
     label: str = "openai"
     model_name: str
     parameters: OpenAiInferenceEngineParams = field(
@@ -169,6 +193,7 @@ class OpenAiInferenceEngine(InferenceEngine, PackageRequirementsMixin):
     _requirement = {
         "openai": "Install openai package using 'pip install --upgrade openai"
     }
+    data_classification_policy = ["public"]
 
     def prepare(self):
         from openai import OpenAI
@@ -183,8 +208,38 @@ class OpenAiInferenceEngine(InferenceEngine, PackageRequirementsMixin):
         self.client = OpenAI(api_key=api_key)
 
     def _infer(self, dataset):
-        return [
-            self.client.chat.completions.create(
+        outputs = []
+        for instance in tqdm(dataset, desc="Inferring with openAI API"):
+            response = self.client.chat.completions.create(
+                messages=[
+                    # {
+                    #     "role": "system",
+                    #     "content": self.system_prompt,
+                    # },
+                    {
+                        "role": "user",
+                        "content": instance["source"],
+                    }
+                ],
+                model=self.model_name,
+                frequency_penalty=self.parameters.frequency_penalty,
+                presence_penalty=self.parameters.presence_penalty,
+                max_tokens=self.parameters.max_tokens,
+                seed=self.parameters.seed,
+                stop=self.parameters.stop,
+                temperature=self.parameters.temperature,
+                top_p=self.parameters.top_p,
+            )
+            output = response.choices[0].message.content
+
+            outputs.append(output)
+
+        return outputs
+
+    def _infer_log_probs(self, dataset):
+        outputs = []
+        for instance in tqdm(dataset, desc="Inferring with openAI API"):
+            response = self.client.chat.completions.create(
                 messages=[
                     # {
                     #     "role": "system",
@@ -203,6 +258,159 @@ class OpenAiInferenceEngine(InferenceEngine, PackageRequirementsMixin):
                 stop=self.parameters.stop,
                 temperature=self.parameters.temperature,
                 top_p=self.parameters.top_p,
+                logprobs=True,
+                top_logprobs=self.parameters.top_logprobs,
+            )
+            top_logprobs_response = response.choices[0].logprobs.content
+            output = [
+                {
+                    "top_tokens": [
+                        {"text": obj.token, "logprob": obj.logprob}
+                        for obj in generated_token.top_logprobs
+                    ]
+                }
+                for generated_token in top_logprobs_response
+            ]
+            outputs.append(output)
+        return outputs
+
+
+class WMLInferenceEngineParams(Artifact):
+    decoding_method: Optional[Literal["greedy", "sample"]] = None
+    length_penalty: Optional[Dict[str, Union[int, float]]] = None
+    temperature: Optional[float] = None
+    top_p: Optional[float] = None
+    top_k: Optional[int] = None
+    random_seed: Optional[int] = None
+    repetition_penalty: Optional[float] = None
+    min_new_tokens: Optional[int] = None
+    max_new_tokens: Optional[int] = None
+    stop_sequences: Optional[List[str]] = None
+    time_limit: Optional[int] = None
+    truncate_input_tokens: Optional[int] = None
+    prompt_variables: Optional[Dict[str, Any]] = None
+    return_options: Optional[Dict[str, bool]] = None
+
+    def initialize_wml_parameters(self) -> Dict[str, Any]:
+        from ibm_watsonx_ai.metanames import GenTextParamsMetaNames
+
+        return {
+            param_name.upper(): param_value
+            for param_name, param_value in self.to_dict().items()
+            if param_value and param_name.upper() in GenTextParamsMetaNames().get()
+        }
+
+
+class WMLInferenceEngine(InferenceEngine, PackageRequirementsMixin):
+    """Runs inference using ibm-watsonx-ai.
+
+    Attributes:
+        client: By default, it is created by a class instance but can be directly
+            provided instead as an instance of 'ibm_watsonx_ai.client.APIClient'.
+        credentials: By default, it is created by a class instance which tries to retrieve
+            proper environment variables ("WML_URL", "WML_PROJECT_ID", "WML_APIKEY").
+            However, either a dictionary with the following keys: "url", "apikey",
+            "project_id", or an instance of 'ibm_watsonx_ai.credentials.Credentials'
+            can be directly provided instead.
+        model_name (str, optional): ID of a model to be used for inference. Mutually
+            exclusive with 'deployment_id'.
+        deployment_id (str, optional): Deployment ID of a tuned model to be used for
+            inference. Mutually exclusive with 'model_name'.
+        parameters (WMLInferenceEngineParams): An instance of 'WMLInferenceEngineParams'
+            which defines parameters used for inference. All the parameters are optional.
+
+    Examples:
+        from .api import load_dataset
+
+        wml_parameters = WMLInferenceEngineParams(top_p=0.5, random_seed=123)
+        wml_credentials = {
+            "url": "some_url", "project_id": "some_id", "api_key": "some_key"
+        }
+        model_name = "google/flan-t5-xxl"
+        wml_inference = WMLInferenceEngine(
+            credentials=wml_credentials,
+            parameters=wml_parameters,
+            model_name=model_name,
+        )
+
+        dataset = load_dataset(
+            dataset_query="card=cards.argument_topic,template_card_index=0,loader_limit=5"
+        )
+        results = wml_inference.infer(dataset["test"])
+    """
+
+    client = None
+    credentials = None
+    model_name: Optional[str] = None
+    deployment_id: Optional[str] = None
+    parameters: WMLInferenceEngineParams = field(
+        default_factory=WMLInferenceEngineParams
+    )
+
+    _parameters: Dict[str, Any] = field(default_factory=dict)
+
+    label: str = "wml"
+    _requirement = {
+        "ibm-watsonx-ai": "Install ibm-watsonx-ai package using 'pip install --upgrade ibm-watsonx-ai'. "
+        "It is advised to have Python version >=3.10 installed, as at lower version this package "
+        "may cause conflicts with other installed packages."
+    }
+
+    data_classification_policy = ["proprietary"]
+
+    @staticmethod
+    def _read_wml_credentials_from_env() -> Dict[str, str]:
+        credentials = {}
+        for env_var_name in ["WML_URL", "WML_PROJECT_ID", "WML_APIKEY"]:
+            env_var = os.environ.get(env_var_name)
+            assert env_var, (
+                f"Error while trying to run 'WMLInferenceEngine'. "
+                f"Please set the env variable: '{env_var_name}', or "
+                f"directly provide an instance of ibm-watsonx-ai 'Credentials' "
+                f"to the engine."
+            )
+
+            name = env_var_name.lower().replace("wml_", "")
+            credentials[name] = env_var
+
+        return credentials
+
+    def _initialize_wml_client(self):
+        from ibm_watsonx_ai.client import APIClient
+
+        if self.credentials is None:
+            self.credentials = self._read_wml_credentials_from_env()
+
+        client = APIClient(credentials=self.credentials)
+        client.set.default_project(self.credentials["project_id"])
+        return client
+
+    def prepare(self):
+        if self.client is None:
+            self.client = self._initialize_wml_client()
+        self._parameters = self.parameters.initialize_wml_parameters()
+
+    def verify(self):
+        assert (
+            self.model_name
+            or self.deployment_id
+            and not (self.model_name and self.deployment_id)
+        ), "Either 'model_name' or 'deployment_id' must be specified, but not both at the same time."
+        super().verify()
+
+    def _infer(self, dataset):
+        from ibm_watsonx_ai.foundation_models import ModelInference
+
+        model = ModelInference(
+            model_id=self.model_name,
+            deployment_id=self.deployment_id,
+            api_client=self.client,
+        )
+
+        return [
+            model.generate_text(
+                prompt=instance["source"],
+                params=self._parameters,
             )
             for instance in dataset
         ]

llm_as_judge.py

@@ -1,6 +1,7 @@
 from typing import Any, Dict, List, Literal, Optional
 
 from .api import evaluate, produce
+from .artifact import Artifact, settings
 from .inference import InferenceEngine, OpenAiInferenceEngine
 from .metrics import BulkInstanceMetric
 from .operator import SequentialOperator
@@ -121,22 +122,25 @@ class LLMAsJudge(BulkInstanceMetric):
         )
 
         card = f"cards.dynamic_cards_for_llm_judges.{self.task}"
-        recipe = (
-            f"card={card},"
-            f"template={self.template},"
-            "demos_pool_size=0,"
-            "num_demos=0"
-        )
+        recipe_args = {
+            "card": card,
+            "template": self.template,
+            "demos_pool_size": 0,
+            "num_demos": 0,
+            "__type__": settings.default_recipe,
+        }
         if self.system_prompt:
-            recipe = f"{recipe},system_prompt={self.system_prompt}"
+            recipe_args["system_prompt"] = self.system_prompt
         if self.format:
-            recipe = f"{recipe},format={self.format}"
-
+            recipe_args["format"] = self.format
+        recipe = Artifact.from_dict(recipe_args)
         dataset = produce(instances, recipe)
         verdicts = self.inference_model.infer(dataset)
         meta_scores = evaluate(predictions=verdicts, data=dataset)
         return [
-            {self.main_score: instance["prediction"], "judge_raw_output": verdict}
-            for instance in meta_scores
-            for verdict in verdicts
+            {
+                self.main_score: instance["processed_prediction"],
+                "judge_raw_output": verdict,
+            }
+            for instance, verdict in zip(meta_scores, verdicts)
         ]

loaders.py

@@ -30,6 +30,7 @@ Available Loaders Overview:
 
 ------------------------
 """
+
 import fnmatch
 import itertools
 import os
@@ -49,9 +50,10 @@ from .dataclass import InternalField, OptionalField
 from .fusion import FixedFusion
 from .logging_utils import get_logger
 from .operator import SourceOperator
-from .operators import AddFields
+from .operators import Set
 from .settings_utils import get_settings
 from .stream import DynamicStream, MultiStream
+from .type_utils import isoftype
 
 logger = get_logger()
 settings = get_settings()
@@ -110,7 +112,7 @@ class Loader(SourceOperator):
                 f"data_classification_policy =['confidential','pii'])\n"
             )
 
-        operator = AddFields(
+        operator = Set(
             fields={"data_classification_policy": self.data_classification_policy}
         )
         return operator(multi_stream)
@@ -176,14 +178,13 @@ class LoadHF(Loader):
                 self._requirements_list.append(requirement)
         super().verify()
 
-    def filtered_load(self, dataset):
+    def filter_load(self, dataset):
+        if not settings.allow_unverified_code:
+            raise ValueError(
+                f"{self.__class__.__name__} cannot run use filtering_lambda expression without setting unitxt.settings.allow_unverified_code=True or by setting environment variable: UNITXT_ALLOW_UNVERIFIED_CODE."
+            )
         logger.info(f"\nLoading filtered by: {self.filtering_lambda};")
-        return MultiStream(
-            {
-                name: dataset[name].filter(eval(self.filtering_lambda))
-                for name in dataset
-            }
-        )
+        return dataset.filter(eval(self.filtering_lambda))
 
     def stream_dataset(self):
         if self._cache is None:
@@ -206,16 +207,17 @@ class LoadHF(Loader):
                         ) from e
                     raise e
 
-            if self.filtering_lambda is not None:
-                dataset = self.filtered_load(dataset)
-
             if self.split is not None:
                 dataset = {self.split: dataset}
 
             self._cache = dataset
+
         else:
             dataset = self._cache
 
+        if self.filtering_lambda is not None:
+            dataset = self.filter_load(dataset)
+
         return dataset
 
     def load_dataset(self):
@@ -239,9 +241,6 @@ class LoadHF(Loader):
                             f"{self.__class__.__name__} cannot run remote code from huggingface without setting unitxt.settings.allow_unverified_code=True or by setting environment variable: UNITXT_ALLOW_UNVERIFIED_CODE."
                         ) from e
 
-            if self.filtering_lambda is not None:
-                dataset = self.filtered_load(dataset)
-
             if self.split is None:
                 for split in dataset.keys():
                     dataset[split] = dataset[split].to_iterable_dataset()
@@ -249,20 +248,25 @@ class LoadHF(Loader):
                 dataset = {self.split: dataset}
 
             self._cache = dataset
+
         else:
             dataset = self._cache
 
+        if self.filtering_lambda is not None:
+            dataset = self.filter_load(dataset)
+
         return dataset
 
-    def split_limited_load(self, split_name):
-        yield from itertools.islice(self._cache[split_name], self.get_limit())
+    def split_limited_load(self, dataset, split_name):
+        yield from itertools.islice(dataset[split_name], self.get_limit())
 
-    def limited_load(self):
+    def limited_load(self, dataset):
         self.log_limited_loading()
         return MultiStream(
             {
                 name: DynamicStream(
-                    generator=self.split_limited_load, gen_kwargs={"split_name": name}
+                    generator=self.split_limited_load,
+                    gen_kwargs={"dataset": dataset, "split_name": name},
                 )
                 for name in self._cache.keys()
             }
@@ -285,7 +289,7 @@ class LoadHF(Loader):
             dataset = self.load_dataset()
 
         if self.get_limit() is not None:
-            return self.limited_load()
+            return self.limited_load(dataset=dataset)
 
         return MultiStream.from_iterables(dataset)
 
@@ -616,7 +620,7 @@ class LoadFromIBMCloud(Loader):
                         object_key,
                         local_dir + "/" + os.path.basename(temp_file.name),
                     )
-                    os.rename(
+                    os.renames(
                         local_dir + "/" + os.path.basename(temp_file.name),
                         local_dir + "/" + data_file,
                     )
@@ -692,6 +696,25 @@ class LoadFromDictionary(Loader):
 
     data: Dict[str, List[Dict[str, Any]]]
 
+    def verify(self):
+        super().verify()
+        if not isoftype(self.data, Dict[str, List[Dict[str, Any]]]):
+            raise ValueError(
+                f"Passed data to LoadFromDictionary is not of type Dict[str, List[Dict[str, Any]]].\n"
+                f"Expected data should map between split name and list of instances.\n"
+                f"Received value: {self.data}\n"
+            )
+        for split in self.data.keys():
+            if len(self.data[split]) == 0:
+                raise ValueError(f"Split {split} has no instances.")
+            first_instance = self.data[split][0]
+            for instance in self.data[split]:
+                if instance.keys() != first_instance.keys():
+                    raise ValueError(
+                        f"Not all instances in split '{split}' have the same fields.\n"
+                        f"instance {instance} has different fields different from {first_instance}"
+                    )
+
     def load_data(self) -> MultiStream:
         self.sef_default_data_classification(
             ["proprietary"], "when loading from python dictionary"

metric.py

@@ -19,13 +19,16 @@ from .file_utils import __file__ as _
 from .formats import __file__ as _
 from .fusion import __file__ as _
 from .generator_utils import __file__ as _
+from .hf_utils import __file__ as _
 from .hf_utils import verify_versions_compatibility
 from .inference import __file__ as _
 from .instructions import __file__ as _
 from .llm_as_judge import __file__ as _
 from .loaders import __file__ as _
 from .logging_utils import __file__ as _
-from .metric_utils import UNITXT_METRIC_SCHEMA, _compute
+from .metric_utils import UNITXT_METRIC_SCHEMA
+from .metric_utils import __file__ as _
+from .metric_utils import _compute
 from .metrics import __file__ as _
 from .normalizers import __file__ as _
 from .operator import __file__ as _
@@ -36,6 +39,7 @@ from .random_utils import __file__ as _
 from .recipe import __file__ as _
 from .register import __file__ as _
 from .schema import __file__ as _
+from .settings_utils import __file__ as _
 from .settings_utils import get_constants
 from .span_lableing_operators import __file__ as _
 from .split_utils import __file__ as _
@@ -50,6 +54,7 @@ from .task import __file__ as _
 from .templates import __file__ as _
 from .text_utils import __file__ as _
 from .type_utils import __file__ as _
+from .utils import __file__ as _
 from .utils import is_package_installed
 from .validate import __file__ as _
 from .version import __file__ as _

metric_utils.py

@@ -9,6 +9,7 @@ from .dataclass import Dataclass
 from .dict_utils import dict_set
 from .operator import (
     MultiStreamOperator,
+    SequentialOperator,
     SequentialOperatorInitializer,
     StreamInitializerOperator,
 )
@@ -18,6 +19,7 @@ from .operators import (
     Copy,
     FlattenInstances,
     MergeStreams,
+    RenameFields,
     SplitByNestedGroup,
 )
 from .register import _reset_env_local_catalogs, register_all_artifacts
@@ -145,6 +147,59 @@ class FromPredictionsAndOriginalData(StreamInitializerOperator):
 # When receiving instances from this scheme, the keys and values are returned as two separate
 # lists, and are converted to a dictionary.
 
+_post_process_steps = SequentialOperator(
+    steps=[
+        Copy(
+            field="prediction",
+            to_field="raw_prediction",
+        ),
+        Copy(
+            field="references",
+            to_field="raw_references",
+        ),
+        Copy(
+            field="source",
+            to_field="task_data/source",
+        ),
+        ApplyOperatorsField(
+            operators_field="postprocessors",
+        ),
+        Copy(
+            field="prediction",
+            to_field="processed_prediction",
+        ),
+        Copy(
+            field="references",
+            to_field="processed_references",
+        ),
+    ]
+)
+
+
+class PostProcessRecipe(SequentialOperatorInitializer):
+    def prepare(self):
+        register_all_artifacts()
+        self.steps = [
+            FromPredictionsAndOriginalData(),
+            _post_process_steps,
+        ]
+
+
+def _post_process(
+    predictions: List[str],
+    references: Iterable,
+    split_name: str = "all",
+):
+    _reset_env_local_catalogs()
+    register_all_artifacts()
+    recipe = PostProcessRecipe()
+
+    multi_stream = recipe(
+        predictions=predictions, references=references, split_name=split_name
+    )
+
+    return [instance["processed_prediction"] for instance in multi_stream[split_name]]
+
 
 class MetricRecipe(SequentialOperatorInitializer):
     calc_confidence_intervals: bool = True
@@ -155,13 +210,7 @@ class MetricRecipe(SequentialOperatorInitializer):
         self.steps = [
             FromPredictionsAndOriginalData(),
             LoadJson(field="task_data"),
-            Copy(
-                field="source",
-                to_field="task_data/source",
-            ),
-            ApplyOperatorsField(
-                operators_field="postprocessors",
-            ),
+            _post_process_steps,
             SplitByNestedGroup(
                 field_name_of_group="group",
                 number_of_fusion_generations=self.number_of_fusion_generations,
@@ -172,6 +221,18 @@ class MetricRecipe(SequentialOperatorInitializer):
             ),
             MultiStreamScoreMean(),
             MergeStreams(),
+            RenameFields(
+                field="raw_prediction",
+                to_field="prediction",
+            ),
+            RenameFields(
+                field="raw_references",
+                to_field="references",
+            ),
+            Copy(
+                field="source",
+                to_field="task_data/source",
+            ),
         ]
 
 

metrics.py

@@ -27,7 +27,7 @@ from .operator import (
     StreamingOperator,
     StreamOperator,
 )
-from .operators import CopyFields
+from .operators import Copy
 from .random_utils import get_seed
 from .settings_utils import get_settings
 from .stream import MultiStream, Stream
@@ -1123,7 +1123,7 @@ class MetricPipeline(MultiStreamOperator, Metric):
 
     def prepare(self):
         super().prepare()
-        self.prepare_score = CopyFields(
+        self.prepare_score = Copy(
             field_to_field=[
                 [
                     f"score/instance/{self.metric._add_score_prefix(self.main_score)}",
@@ -2134,9 +2134,7 @@ class Detector(BulkInstanceMetric):
         return self.pipe(predictions, batch_size=self.batch_size)
 
 
-class LlamaIndexCorrectness(InstanceMetric):
-    """LlamaIndex based metric class for evaluating correctness."""
-
+class LlamaIndexLLMMetric(InstanceMetric):
     model_name: str = ""
     main_score: str = ""
     prediction_type: str = "str"
@@ -2151,6 +2149,34 @@ class LlamaIndexCorrectness(InstanceMetric):
 
     _requirements_list: List[str] = ["llama_index"]
 
+    def prepare(self):
+        self.model_name_normalized = self.model_name.replace(".", "_").replace("-", "_")
+        self.main_score: str = f"llama_index_by_{self.model_name_normalized}_judge"
+
+        self.reduction_map: Dict[str, List[str]] = {"mean": [self.main_score]}
+
+        if self.model_name in self.openai_models:
+            from llama_index.llms.openai import OpenAI
+
+            self.llm = OpenAI("gpt-3.5-turbo")
+        elif self.model_name in self.mock_models:
+            from llama_index.core.llms.mock import MockLLM
+
+            self.llm = MockLLM(system_prompt="5")  # perfect score
+        else:
+            raise NotImplementedError(
+                f"LlamaIndexLLM metric does not support {self.model_name}, currently only gpt-3.5-turbo is supported"
+            )
+
+    def _model_using_extrnal_api(self):
+        return self.model_name in self.external_api_models
+
+
+class LlamaIndexCorrectness(LlamaIndexLLMMetric):
+    """LlamaIndex based metric class for evaluating correctness."""
+
+    score_prefix = "correctness_"
+
     @staticmethod
     def _custom_parser(eval_response: str):
         """Default parser function for evaluation response.
@@ -2174,37 +2200,14 @@ class LlamaIndexCorrectness(InstanceMetric):
         reasoning = reasoning_str.lstrip("\n")
         return score, reasoning
 
-    def _model_using_extrnal_api(self):
-        return self.model_name in self.external_api_models
-
     def prepare(self):
         """Initialization method for the metric. Initializes the CorrectnessEvaluator with the OpenAI model."""
         super().prepare()
 
-        self.model_name_normalized = self.model_name.replace(".", "_").replace("-", "_")
-        self.main_score: str = (
-            f"correctness_llama_index_by_{self.model_name_normalized}_judge"
-        )
-
-        self.reduction_map: Dict[str, List[str]] = {"mean": [self.main_score]}
-
         from llama_index.core.evaluation import CorrectnessEvaluator
 
-        if self.model_name in self.openai_models:
-            from llama_index.llms.openai import OpenAI
-
-            llm = OpenAI("gpt-3.5-turbo")
-        elif self.model_name in self.mock_models:
-            from llama_index.core.llms.mock import MockLLM
-
-            llm = MockLLM(system_prompt="5")  # perfect score
-        else:
-            raise NotImplementedError(
-                f"LlamaIndexCorrectnessMetric does not support {self.model_name}, currently only gpt-3.5-turbo is supported"
-            )
-
         self.evaluator = CorrectnessEvaluator(
-            llm=llm, parser_function=self._custom_parser
+            llm=self.llm, parser_function=self._custom_parser
         )
 
     def compute(
@@ -2226,9 +2229,6 @@ class LlamaIndexCorrectness(InstanceMetric):
         Raises:
             AssertionError: If the input does not meet the expected format.
         """
-        # treat the references as the questions and the predictions as answers
-        # assume a single reference
-
         query = task_data["question"]
 
         contexts = None
@@ -2247,11 +2247,36 @@ class LlamaIndexCorrectness(InstanceMetric):
             )
         result = max([results.score for results in per_reference_results])
 
-        return {
-            self.main_score: result / 5,
-            # "score_name": self.main_score,
-            # "feedback": result.feedback, # removed since this cannot be tested
-        }
+        return {self.main_score: result / 5}
+
+
+class LlamaIndexFaithfulness(LlamaIndexLLMMetric):
+    """LlamaIndex based metric class for evaluating faithfulness."""
+
+    score_prefix = "faithfulness_"
+
+    def prepare(self):
+        """Initialization method for the metric. Initializes the FaithfulnessEvaluator with the OpenAI model."""
+        super().prepare()
+
+        from llama_index.core.evaluation import FaithfulnessEvaluator
+
+        self.evaluator = FaithfulnessEvaluator(llm=self.llm)
+
+    def compute(
+        self,
+        references: List[str],
+        prediction: str,
+        task_data: Dict,
+    ) -> Dict[str, Any]:
+        result = self.evaluator.evaluate(
+            query=task_data["question"],
+            response=prediction,
+            contexts=task_data["contexts"],
+        )
+        score = result.score
+
+        return {self.main_score: score}
 
 
 class Perplexity(BulkInstanceMetric):

operator.py

@@ -117,54 +117,6 @@ class SideEffectOperator(StreamingOperator):
         pass
 
 
-class SourceOperator(StreamingOperator):
-    """A class representing a source operator in the streaming system.
-
-    A source operator is responsible for generating the data stream from some source, such as a database or a file.
-    This is the starting point of a stream processing pipeline.
-    The `SourceOperator` class is a type of `SourceOperator`, which is a special type of `StreamingOperator`
-    that generates an output stream but does not take any input streams.
-
-    When called, a `SourceOperator` invokes its `process` method, which should be implemented by all subclasses
-    to generate the required `MultiStream`.
-
-    """
-
-    caching: bool = NonPositionalField(default=None)
-
-    def __call__(self, multi_stream: Optional[MultiStream] = None) -> MultiStream:
-        multi_stream = self.process()
-        if self.caching is not None:
-            multi_stream.set_caching(self.caching)
-        return multi_stream
-
-    @abstractmethod
-    def process(self) -> MultiStream:
-        pass
-
-
-class StreamInitializerOperator(SourceOperator):
-    """A class representing a stream initializer operator in the streaming system.
-
-    A stream initializer operator is a special type of `SourceOperator` that is capable of taking parameters during the stream generation process. This can be useful in situations where the stream generation process needs to be customized or configured based on certain parameters.
-
-    When called, a `StreamInitializerOperator` invokes its `process` method, passing any supplied arguments and keyword arguments. The `process` method should be implemented by all subclasses to generate the required `MultiStream` based on the given arguments and keyword arguments.
-
-    """
-
-    caching: bool = NonPositionalField(default=None)
-
-    def __call__(self, *args, **kwargs) -> MultiStream:
-        multi_stream = self.process(*args, **kwargs)
-        if self.caching is not None:
-            multi_stream.set_caching(self.caching)
-        return self.process(*args, **kwargs)
-
-    @abstractmethod
-    def process(self, *args, **kwargs) -> MultiStream:
-        pass
-
-
 def instance_generator(instance):
     yield instance
 
@@ -213,6 +165,55 @@ class MultiStreamOperator(StreamingOperator):
         return next(iter(processed_multi_stream[stream_name]))
 
 
+class SourceOperator(MultiStreamOperator):
+    """A class representing a source operator in the streaming system.
+
+    A source operator is responsible for generating the data stream from some source, such as a database or a file.
+    This is the starting point of a stream processing pipeline.
+    The `SourceOperator` class is a type of `SourceOperator`, which is a special type of `StreamingOperator`
+    that generates an output stream but does not take any input streams.
+
+    When called, a `SourceOperator` invokes its `process` method, which should be implemented by all subclasses
+    to generate the required `MultiStream`.
+
+    """
+
+    def _process_multi_stream(
+        self, multi_stream: Optional[MultiStream] = None
+    ) -> MultiStream:
+        result = self.process()
+        assert isinstance(
+            result, MultiStream
+        ), "MultiStreamOperator must return a MultiStream"
+        return result
+
+    @abstractmethod
+    def process(self) -> MultiStream:
+        pass
+
+
+class StreamInitializerOperator(SourceOperator):
+    """A class representing a stream initializer operator in the streaming system.
+
+    A stream initializer operator is a special type of `SourceOperator` that is capable of taking parameters during the stream generation process. This can be useful in situations where the stream generation process needs to be customized or configured based on certain parameters.
+
+    When called, a `StreamInitializerOperator` invokes its `process` method, passing any supplied arguments and keyword arguments. The `process` method should be implemented by all subclasses to generate the required `MultiStream` based on the given arguments and keyword arguments.
+
+    """
+
+    caching: bool = NonPositionalField(default=None)
+
+    def __call__(self, *args, **kwargs) -> MultiStream:
+        multi_stream = self.process(*args, **kwargs)
+        if self.caching is not None:
+            multi_stream.set_caching(self.caching)
+        return self.process(*args, **kwargs)
+
+    @abstractmethod
+    def process(self, *args, **kwargs) -> MultiStream:
+        pass
+
+
 class StreamOperator(MultiStreamOperator):
     """A class representing a single-stream operator in the streaming system.
 
@@ -458,15 +459,8 @@ class InstanceOperatorWithMultiStreamAccess(StreamingOperator):
         pass
 
 
-class SequentialOperator(MultiStreamOperator):
-    """A class representing a sequential operator in the streaming system.
-
-    A sequential operator is a type of `MultiStreamOperator` that applies a sequence of other operators to a
-    `MultiStream`. It maintains a list of `StreamingOperator`s and applies them in order to the `MultiStream`.
-    """
-
-    max_steps = None
-
+class SequentialMixin(Artifact):
+    max_steps: Optional[int] = None
     steps: List[StreamingOperator] = field(default_factory=list)
 
     def num_steps(self) -> int:
@@ -488,13 +482,21 @@ class SequentialOperator(MultiStreamOperator):
     def _get_max_steps(self):
         return self.max_steps if self.max_steps is not None else len(self.steps)
 
+
+class SequentialOperator(MultiStreamOperator, SequentialMixin):
+    """A class representing a sequential operator in the streaming system.
+
+    A sequential operator is a type of `MultiStreamOperator` that applies a sequence of other operators to a
+    `MultiStream`. It maintains a list of `StreamingOperator`s and applies them in order to the `MultiStream`.
+    """
+
     def process(self, multi_stream: Optional[MultiStream] = None) -> MultiStream:
         for operator in self.steps[0 : self._get_max_steps()]:
             multi_stream = operator(multi_stream)
         return multi_stream
 
 
-class SourceSequentialOperator(SequentialOperator):
+class SourceSequentialOperator(SourceOperator, SequentialMixin):
     """A class representing a source sequential operator in the streaming system.
 
     A source sequential operator is a type of `SequentialOperator` that starts with a source operator.
@@ -502,9 +504,6 @@ class SourceSequentialOperator(SequentialOperator):
     that the other operators then process.
     """
 
-    def __call__(self) -> MultiStream:
-        return super().__call__()
-
     def process(self, multi_stream: Optional[MultiStream] = None) -> MultiStream:
         assert (
             self.num_steps() > 0

operators.py

@@ -16,11 +16,17 @@ The primary task in any operator development is to implement the `process` funct
 
 General or Specelized Operators
 --------------------------------
-Some operators are specielized in specific task such as:
+Some operators are specielized in specific data or specific operations such as:
 
-- :class:`loaders<unitxt.loaders>` for loading data.
+- :class:`loaders<unitxt.loaders>` for accessing data from various sources.
 - :class:`splitters<unitxt.splitters>` for fixing data splits.
+- :class:`stream_operators<unitxt.stream_operators>` for changing joining and mixing streams.
 - :class:`struct_data_operators<unitxt.struct_data_operators>` for structured data operators.
+- :class:`collections_operators<unitxt.collections_operators>` for handling collections such as lists and dictionaries.
+- :class:`dialog_operators<unitxt.dialog_operators>` for handling dialogs.
+- :class:`string_operators<unitxt.string_operators>` for handling strings.
+- :class:`span_labeling_operators<unitxt.span_labeling_operators>` for handling strings.
+- :class:`fusion<unitxt.fusion>` for fusing and mixing datasets.
 
 Other specelized operators are used by unitxt internally:
 
@@ -59,6 +65,7 @@ import requests
 
 from .artifact import Artifact, fetch_artifact
 from .dataclass import DeprecatedField, NonPositionalField, OptionalField
+from .deprecation_utils import deprecation
 from .dict_utils import dict_delete, dict_get, dict_set, is_subpath
 from .operator import (
     InstanceOperator,
@@ -222,7 +229,7 @@ class FlattenInstances(InstanceOperator):
         return flatten_dict(instance, parent_key=self.parent_key, sep=self.sep)
 
 
-class AddFields(InstanceOperator):
+class Set(InstanceOperator):
     """Adds specified fields to each instance in a given stream or all streams (default) If fields exist, updates them.
 
     Args:
@@ -232,17 +239,17 @@ class AddFields(InstanceOperator):
 
     Examples:
         # Add a 'classes' field with a value of a list "positive" and "negative" to all streams
-        AddFields(fields={"classes": ["positive","negatives"]})
+        Set(fields={"classes": ["positive","negatives"]})
 
         # Add a 'start' field under the 'span' field with a value of 0 to all streams
-        AddFields(fields={"span/start": 0}
+        Set(fields={"span/start": 0}
 
         # Add a 'classes' field with a value of a list "positive" and "negative" to 'train' stream
-        AddFields(fields={"classes": ["positive","negatives"], apply_to_stream=["train"]})
+        Set(fields={"classes": ["positive","negatives"], apply_to_stream=["train"]})
 
         # Add a 'classes' field on a given list, prevent modification of original list
         # from changing the instance.
-        AddFields(fields={"classes": alist}), use_deepcopy=True)
+        Set(fields={"classes": alist}), use_deepcopy=True)
         # if now alist is modified, still the instances remain intact.
     """
 
@@ -265,6 +272,11 @@ class AddFields(InstanceOperator):
         return instance
 
 
+@deprecation(version="1.11.0", alternative=Set)
+class AddFields(Set):
+    pass
+
+
 class RemoveFields(InstanceOperator):
     """Remove specified fields from each instance in a stream.
 
@@ -1049,6 +1061,7 @@ class Copy(FieldOperator):
         return copy.deepcopy(value)
 
 
+@deprecation(version="1.11.0", alternative=Copy)
 class CopyFields(Copy):
     pass
 
@@ -1392,7 +1405,8 @@ class ComputeExpressionMixin(Artifact):
             return eval(self.expression, self.globals, instance)
 
         raise ValueError(
-            f"Cannot run expression by {self} when unitxt.settings.allow_unverified_code=False either set it to True or set {settings.allow_unverified_code_key} environment variable."
+            f"Cannot evaluate expression in {self} when unitxt.settings.allow_unverified_code=False - either set it to True or set {settings.allow_unverified_code_key} environment variable."
+            "\nNote: If using test_card() with the default setting, increase loader_limit to avoid missing conditions due to limited data sampling."
         )
 
 
@@ -1556,7 +1570,7 @@ class ExtractMostCommonFieldValues(MultiStreamOperator):
             for ele in values_and_counts
         ]
 
-        addmostcommons = AddFields(fields={self.to_field: values_to_keep})
+        addmostcommons = Set(fields={self.to_field: values_to_keep})
         return addmostcommons(multi_stream)
 
 

processors.py

@@ -33,6 +33,11 @@ class ToListByComma(SplitStrip):
     strip_every_element = True
 
 
+class ToListByCommaSpace(SplitStrip):
+    delimiter = ", "
+    strip_every_element = True
+
+
 class RegexParser(FieldOperator):
     """A processor that uses regex in order to parse a string."""
 

settings_utils.py

@@ -1,7 +1,6 @@
+import importlib.util
 import os
 
-import pkg_resources
-
 from .version import version
 
 
@@ -141,11 +140,11 @@ if Constants.is_uninitilized():
     constants.dataset_file = os.path.join(os.path.dirname(__file__), "dataset.py")
     constants.metric_file = os.path.join(os.path.dirname(__file__), "metric.py")
     constants.local_catalog_path = os.path.join(os.path.dirname(__file__), "catalog")
-    try:
-        constants.default_catalog_path = pkg_resources.resource_filename(
-            "unitxt", "catalog"
-        )
-    except ModuleNotFoundError:
+    unitxt_pkg = importlib.util.find_spec("unitxt")
+    if unitxt_pkg and unitxt_pkg.origin:
+        unitxt_dir = os.path.dirname(unitxt_pkg.origin)
+        constants.default_catalog_path = os.path.join(unitxt_dir, "catalog")
+    else:
         constants.default_catalog_path = constants.local_catalog_path
     constants.catalog_dir = constants.local_catalog_path
     constants.dataset_url = "unitxt/data"

standard.py

@@ -5,7 +5,7 @@ from .dataclass import Field, InternalField, NonPositionalField, OptionalField
 from .formats import Format, SystemFormat
 from .logging_utils import get_logger
 from .operator import SequentialOperator, SourceSequentialOperator, StreamingOperator
-from .operators import AddFields, Augmentor, NullAugmentor, StreamRefiner
+from .operators import Augmentor, NullAugmentor, Set, StreamRefiner
 from .recipe import Recipe
 from .schema import ToUnitxtGroup
 from .splitters import Sampler, SeparateSplit, SpreadSplit
@@ -120,6 +120,12 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
             metrics = self.card.task.metrics
         else:
             metrics = self.metrics
+
+        metrics = [
+            metric if isinstance(metric, str) else metric.to_json()
+            for metric in metrics
+        ]
+
         return metrics, postprocessors
 
     def set_pipelines(self):
@@ -220,7 +226,7 @@ class BaseRecipe(Recipe, SourceSequentialOperator):
             self.loading.steps.append(StreamRefiner(max_instances=self.loader_limit))
 
         self.metadata.steps.append(
-            AddFields(
+            Set(
                 fields={
                     "recipe_metadata": {
                         "template": self.template,

string_operators.py

@@ -37,6 +37,27 @@ class TokensSplit(FieldOperator):
         return self.tokenizer.tokenize(value)
 
 
+class TokensSlice(FieldOperator):
+    model: str
+    start: Optional[int] = None
+    stop: Optional[int] = None
+    step: Optional[int] = None
+
+    _requirements_list = ["transformers"]
+
+    def prepare(self):
+        super().prepare()
+        from transformers import AutoTokenizer
+
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model)
+
+    def process_value(self, value: str) -> str:
+        encoded = self.tokenizer.encode(value)
+        slicer = slice(self.start, self.stop, self.step)
+        sliced = encoded[slicer]
+        return self.tokenizer.decode(sliced)
+
+
 class Join(FieldOperator):
     by: str
 

struct_data_operators.py

@@ -14,6 +14,7 @@ For key-value pairs, expected input format is:
 {"key1": "value1", "key2": value2, "key3": "value3"}
 ------------------------
 """
+
 import json
 import random
 from abc import ABC, abstractmethod

task.py

@@ -27,6 +27,10 @@ class Task(InstanceOperator):
         prediction_type (Optional[str]):
             Need to be consistent with all used metrics. Defaults to None, which means that it will
             be set to Any.
+        defaults (Optional[Dict[str, Any]]):
+            An optional dictionary with default values for chosen input/output keys. Needs to be
+            consistent with names and types provided in 'inputs' and/or 'outputs' arguments.
+            Will not overwrite values if already provided in a given instance.
 
     The output instance contains three fields:
         "inputs" whose value is a sub-dictionary of the input instance, consisting of all the fields listed in Arg 'inputs'.
@@ -39,6 +43,7 @@ class Task(InstanceOperator):
     metrics: List[str]
     prediction_type: Optional[str] = None
     augmentable_inputs: List[str] = []
+    defaults: Optional[Dict[str, Any]] = None
 
     def verify(self):
         for io_type in ["inputs", "outputs"]:
@@ -72,6 +77,8 @@ class Task(InstanceOperator):
                 augmentable_input in self.inputs
             ), f"augmentable_input {augmentable_input} is not part of {self.inputs}"
 
+        self.verify_defaults()
+
     @staticmethod
     @lru_cache(maxsize=None)
     def get_metric_prediction_type(metric_id: str):
@@ -99,9 +106,46 @@ class Task(InstanceOperator):
                 f"metric's prediction type ({metric_prediction_type}) are different."
             )
 
+    def verify_defaults(self):
+        if self.defaults:
+            if not isinstance(self.defaults, dict):
+                raise ValueError(
+                    f"If specified, the 'defaults' must be a dictionary, "
+                    f"however, '{self.defaults}' was provided instead, "
+                    f"which is of type '{type(self.defaults)}'."
+                )
+
+            for default_name, default_value in self.defaults.items():
+                assert isinstance(default_name, str), (
+                    f"If specified, all keys of the 'defaults' must be strings, "
+                    f"however, the key '{default_name}' is of type '{type(default_name)}'."
+                )
+
+                val_type = self.inputs.get(default_name) or self.outputs.get(
+                    default_name
+                )
+
+                assert val_type, (
+                    f"If specified, all keys of the 'defaults' must refer to a chosen "
+                    f"key in either 'inputs' or 'outputs'. However, the name '{default_name}' "
+                    f"was provided which does not match any of the keys."
+                )
+
+                assert isoftype(default_value, parse_type_string(val_type)), (
+                    f"The value of '{default_name}' from the 'defaults' must be of "
+                    f"type '{val_type}', however, it is of type '{type(default_value)}'."
+                )
+
+    def set_default_values(self, instance: Dict[str, Any]) -> Dict[str, Any]:
+        if self.defaults:
+            instance = {**self.defaults, **instance}
+        return instance
+
     def process(
         self, instance: Dict[str, Any], stream_name: Optional[str] = None
     ) -> Dict[str, Any]:
+        instance = self.set_default_values(instance)
+
         verify_required_schema(self.inputs, instance)
         verify_required_schema(self.outputs, instance)
 

text_utils.py

@@ -69,7 +69,7 @@ def camel_to_snake_case(s):
     return s.lower()
 
 
-def construct_dict_str(d, indent=0, indent_delta=4, max_chars=None):
+def construct_dict_str(d, indent=0, indent_delta=4, max_chars=None, keys=None):
     """Constructs a formatted string of a dictionary.
 
     Args:
@@ -77,13 +77,21 @@ def construct_dict_str(d, indent=0, indent_delta=4, max_chars=None):
         indent (int, optional): The current level of indentation. Defaults to 0.
         indent_delta (int, optional): The amount of spaces to add for each level of indentation. Defaults to 4.
         max_chars (int, optional): The maximum number of characters for each line. Defaults to terminal width - 10.
+        keys (List[Str], optional): the list of fields to print
     """
     max_chars = max_chars or shutil.get_terminal_size()[0] - 10
     indent_str = " " * indent
     indent_delta_str = " " * indent_delta
     res = ""
 
-    for key, value in d.items():
+    if keys is None:
+        keys = d.keys()
+    for key in keys:
+        if key not in d.keys():
+            raise ValueError(
+                f"Dictionary does not contain field {key} specified in 'keys' argument. The available keys are {d.keys()}"
+            )
+        value = d[key]
         if isinstance(value, dict):
             res += f"{indent_str}{key}:\n"
             res += construct_dict_str(value, indent + indent_delta, max_chars=max_chars)
@@ -106,10 +114,12 @@ def construct_dict_str(d, indent=0, indent_delta=4, max_chars=None):
     return res
 
 
-def print_dict(d, indent=0, indent_delta=4, max_chars=None):
-    dict_str = construct_dict_str(d, indent, indent_delta, max_chars)
+def print_dict(
+    d, indent=0, indent_delta=4, max_chars=None, keys_to_print=None, log_level="info"
+):
+    dict_str = construct_dict_str(d, indent, indent_delta, max_chars, keys_to_print)
     dict_str = "\n" + dict_str
-    logger.info(dict_str)
+    getattr(logger, log_level)(dict_str)
 
 
 def nested_tuple_to_string(nested_tuple: tuple) -> str:
@@ -150,6 +160,7 @@ def is_made_of_sub_strings(string, sub_strings):
 # It also prepares for the case that  __description__ tag does not contain balanced
 # parentheses, since it is often cut in the middle, (with  "... see more at")
 # flake8: noqa: B007
+# flake8: noqa: C901
 def lines_defining_obj_in_card(
     all_lines: List[str], obj_name: str, start_search_at_line: int = 0
 ) -> Tuple[int, int]:
@@ -165,25 +176,53 @@ def lines_defining_obj_in_card(
     ending_line = starting_line - 1
     while ending_line < len(all_lines):
         ending_line += 1
-        num_of_opens += len(re.findall(r"[({[]", all_lines[ending_line]))
-        num_of_closes += len(re.findall(r"[)}\]]", all_lines[ending_line]))
-        if num_of_closes == num_of_opens:
-            break
+
         if "__description__" in all_lines[ending_line]:
-            # can not trust parentheses inside description.
-            # trust the indentation enforced by ruff, and the way we build __description__:
+            # can not trust parentheses inside description, because this is mainly truncated
+            # free text.
+            # We do trust the indentation enforced by ruff, and the way we build __description__:
             # a line consisting of only __description__=(
             # followed by one or more lines of text, can not trust opens and closes
             # in them, followed by a line consisting of only:  ),
             # where the ) is indented with the beginning of __description__
+            # We also prepare for the case that, when not entered by us, __description__=
+            # is not followed by a ( and the whole description does not end with a single ) in its line.
+            # We build on ruff making the line following the description start with same indentation
+            # or 4 less (i.e., the following line is the closing of the card).
             tag_indentation = all_lines[ending_line].index("__description__")
-            last_line_to_start_with = (" " * tag_indentation) + ")"
-            while not all_lines[ending_line].startswith(last_line_to_start_with):
+            starts_with_parent = "__description__=(" in all_lines[ending_line]
+            if starts_with_parent:
+                last_line_to_start_with = (" " * tag_indentation) + r"\)"
+            else:
+                # actually, the line that follows the description
+                last_line_to_start_with1 = (" " * tag_indentation) + "[^ ]"
+                last_line_to_start_with2 = (" " * (tag_indentation - 4)) + "[^ ]"
+                last_line_to_start_with = (
+                    "("
+                    + last_line_to_start_with1
+                    + "|"
+                    + last_line_to_start_with2
+                    + ")"
+                )
+            ending_line += 1
+            while not re.search("^" + last_line_to_start_with, all_lines[ending_line]):
                 ending_line += 1
             if "__description__" in obj_name:
-                return (starting_line, ending_line)
-            num_of_closes += 1  # for this last line of desc
-            # continue to the line following the end of description
+                return (
+                    starting_line,
+                    ending_line if starts_with_parent else ending_line - 1,
+                )
+
+            if starts_with_parent:
+                ending_line += 1
+
+            # we conrinue in card, having passed the description, ending line points
+            # to the line that follows description
+
+        num_of_opens += len(re.findall(r"[({[]", all_lines[ending_line]))
+        num_of_closes += len(re.findall(r"[)}\]]", all_lines[ending_line]))
+        if num_of_closes == num_of_opens:
+            break
 
     if num_of_closes != num_of_opens:
         raise ValueError(

utils.py

@@ -1,4 +1,6 @@
+import importlib.util
 import json
+import os
 from functools import lru_cache
 from typing import Any, Dict
 
@@ -47,13 +49,16 @@ def load_json(path):
             ) from e
 
 
-def save_json(path, data):
+def save_to_file(path, data):
     with open(path, "w") as f:
-        dumped = json.dumps(data, indent=4, ensure_ascii=False)
-        f.write(dumped)
+        f.write(data)
         f.write("\n")
 
 
+def json_dump(data):
+    return json.dumps(data, indent=4, ensure_ascii=False)
+
+
 def is_package_installed(package_name):
     """Check if a package is installed.
 
@@ -113,3 +118,15 @@ def safe_eval(expression: str, context: dict, allowed_tokens: list) -> any:
     raise ValueError(
         f"The expression '{expression}' can not be evaluated because it contains tokens outside the allowed list of {allowed_sub_strings}."
     )
+
+
+def import_module_from_file(file_path):
+    # Get the module name (file name without extension)
+    module_name = os.path.splitext(os.path.basename(file_path))[0]
+    # Create a module specification
+    spec = importlib.util.spec_from_file_location(module_name, file_path)
+    # Create a new module based on the specification
+    module = importlib.util.module_from_spec(spec)
+    # Load the module
+    spec.loader.exec_module(module)
+    return module

version.py

@@ -1 +1 @@
-version = "1.10.0"
+version = "1.10.1"