Upload folder using huggingface_hub

api.py

@@ -1,7 +1,6 @@
 import hashlib
 import inspect
 import json
-import tempfile
 from datetime import datetime
 from functools import lru_cache
 from typing import Any, Dict, List, Optional, Union
@@ -135,36 +134,39 @@ def create_dataset(
 
 
 def _source_to_dataset(
-    source: SourceOperator, split=None, use_cache=False, streaming=False
+    source: SourceOperator,
+    split=None,
+    use_cache=False,
+    streaming=False,
 ):
     from .dataset import Dataset as UnitxtDataset
 
     stream = source()
 
-    with tempfile.TemporaryDirectory() as dir_to_be_deleted:
-        cache_dir = dir_to_be_deleted if not use_cache else None
+    try:
         ds_builder = UnitxtDataset(
             dataset_name="unitxt",
             config_name="recipe-" + short_hex_hash(repr(source)),
-            hash=hash(repr(source)),
             version=constants.version,
-            cache_dir=cache_dir,
         )
         if split is not None:
             stream = {split: stream[split]}
         ds_builder._generators = stream
 
-        try:
-            ds_builder.download_and_prepare()
+        ds_builder.download_and_prepare(
+            verification_mode="no_checks",
+            download_mode=None if use_cache else "force_redownload",
+        )
 
-            if streaming:
-                return ds_builder.as_streaming_dataset(split=split)
+        if streaming:
+            return ds_builder.as_streaming_dataset(split=split)
 
-            return ds_builder.as_dataset(
-                split=split, run_post_process=False, verification_mode="no_checks"
-            )
-        except DatasetGenerationError as e:
-            raise e.__cause__
+        return ds_builder.as_dataset(
+            split=split, run_post_process=False, verification_mode="no_checks"
+        )
+
+    except DatasetGenerationError as e:
+        raise e.__cause__
 
 
 def load_dataset(

card.py

@@ -21,8 +21,6 @@ class TaskCard(Artifact):
             specifies the fields (of the already (pre)processed instance) making the inputs, the fields making the outputs, and the metrics to be used for evaluating the model output.
         templates:
             format strings to be applied on the input fields (specified by the task) and the output fields. The template also carries the instructions and the list of postprocessing steps, to be applied to the model output.
-        default_template:
-            a default template for tasks with very specific task dataset specific template
     """
 
     loader: Loader
@@ -31,5 +29,4 @@ class TaskCard(Artifact):
     templates: Union[
         TemplatesDict, TemplatesList, Dict[str, Template], List[Template]
     ] = None
-    default_template: Template = None
     sampler: Sampler = OptionalField(default_factory=RandomSampler)

collections.py

@@ -22,6 +22,10 @@ class Collection(Artifact):
     def keys(self) -> List[Hashable]:
         pass
 
+    @abstractmethod
+    def __len__(self):
+        pass
+
 
 class ListCollection(Collection):
     items: List[Artifact] = field(default_factory=list)
@@ -48,6 +52,11 @@ class DictCollection(Collection):
     def keys(self) -> List[Hashable]:
         return list(self.items.keys())
 
+    def len(self):
+        return len(self.items)
+
+    def __len__(self):
+        return len(self.items)
 
 class ItemPicker(Artifact):
     item: object = None

data.py

@@ -15,7 +15,6 @@ 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 .db_utils import __file__ as _
 from .deprecation_utils import __file__ as _
 from .dialog_operators import __file__ as _
 from .dict_utils import __file__ as _
@@ -58,6 +57,7 @@ from .settings_utils import get_constants
 from .span_lableing_operators import __file__ as _
 from .split_utils import __file__ as _
 from .splitters import __file__ as _
+from .sql_utils import __file__ as _
 from .standard import __file__ as _
 from .stream import __file__ as _
 from .stream_operators import __file__ as _

fusion.py

@@ -34,11 +34,7 @@ class BaseFusion(SourceOperator):
             for i in range(len(self.subsets)):
                 self.named_subsets[i] = self.subsets[i]
         else:
-            for name, origin in self.subsets.items():
-                try:
-                    self.named_subsets[name] = origin
-                except Exception as e:
-                    raise RuntimeError(f"Exception in subset: {name}") from e
+            self.named_subsets = self.subsets
 
     def splits(self) -> List[str]:
         self.prepare_subsets()

image_operators.py

@@ -41,7 +41,9 @@ def image_to_data_url(image: Image, default_format="JPEG"):
     https://developer.mozilla.org/en-US/docs/Web/URI/Schemes/data
     """
     image_format = image["format"] if image["format"] else default_format
-    base64_image = _image_to_bytes(image["image"], format=image_format.upper())
+    base64_image = _image_to_bytes(
+        image["image"].convert("RGB"), format=image_format.upper()
+    )
     return ImageDataString(f"data:image/{image_format.lower()};base64,{base64_image}")
 
 

inference.py

@@ -1,6 +1,8 @@
 import abc
 import asyncio
+import base64
 import dataclasses
+import io
 import json
 import logging
 import os
@@ -26,14 +28,14 @@ from typing import (
     Union,
 )
 
-from datasets import Dataset, DatasetDict
+from datasets import Dataset, DatasetDict, Image
 from tqdm import tqdm, trange
 from tqdm.asyncio import tqdm_asyncio
 
 from .artifact import Artifact
 from .dataclass import InternalField, NonPositionalField
 from .deprecation_utils import deprecation
-from .error_utils import UnitxtError
+from .error_utils import UnitxtError, UnitxtWarning
 from .image_operators import (
     EncodeImageToString,
     ImageDataString,
@@ -277,6 +279,12 @@ class LogProbInferenceEngine(abc.ABC, Artifact):
         """
         pass
 
+    def _mock_infer_log_probs(
+        self,
+        dataset: Union[List[Dict[str, Any]], Dataset],
+    ) -> Union[List[str], List[TextGenerationInferenceOutput]]:
+        return [mock_logprobs_default_value_factory() for instance in dataset]
+
     def infer_log_probs(
         self,
         dataset: Union[List[Dict[str, Any]], Dataset],
@@ -296,7 +304,12 @@ class LogProbInferenceEngine(abc.ABC, Artifact):
             )
 
         [self.verify_instance(instance) for instance in dataset]
-        return self._infer_log_probs(dataset, return_meta_data)
+
+        if settings.mock_inference_mode:
+            result = self._mock_infer_log_probs(dataset)
+        else:
+            result = self._infer_log_probs(dataset, return_meta_data)
+        return result
 
 
 class LazyLoadMixin(Artifact):
@@ -811,9 +824,12 @@ class HFPeftInferenceEngine(HFAutoModelInferenceEngine):
             if AutoConfig.from_pretrained(self.model_name).is_encoder_decoder
             else AutoPeftModelForCausalLM
         )
+        path = self.peft_config.base_model_name_or_path
+        if settings.hf_offline_models_path is not None:
+            path = os.path.join(settings.hf_offline_models_path, path)
 
         self.model = model_class.from_pretrained(
-            pretrained_model_name_or_path=self.peft_config.base_model_name_or_path,
+            pretrained_model_name_or_path=path,
             trust_remote_code=True,
             device_map=self.device_map,
             low_cpu_mem_usage=self.low_cpu_mem_usage,
@@ -858,10 +874,15 @@ class HFPipelineBasedInferenceEngine(
     def _define_task(self):
         from transformers import AutoConfig
 
+        path = self.model_name
+        if settings.hf_offline_models_path is not None:
+            path = os.path.join(settings.hf_offline_models_path, path)
+
         self.task = (
             "text2text-generation"
             if AutoConfig.from_pretrained(
-                self.model_name, trust_remote_code=True
+                path,
+                trust_remote_code=True,
             ).is_encoder_decoder
             else "text-generation"
         )
@@ -899,11 +920,15 @@ class HFPipelineBasedInferenceEngine(
     def _create_pipeline(self, model_args: Dict[str, Any]):
         from transformers import pipeline
 
+        path = self.model_name
+        if settings.hf_offline_models_path is not None:
+            path = os.path.join(settings.hf_offline_models_path, path)
+
         self.model = pipeline(
-            model=self.model_name,
+            model=path,
             task=self.task,
             use_fast=self.use_fast_tokenizer,
-            trust_remote_code=True,
+            trust_remote_code=settings.allow_unverified_code,
             **model_args,
             **self.to_dict(
                 [HFGenerationParamsMixin],
@@ -1143,15 +1168,14 @@ class OllamaInferenceEngine(
         import ollama
 
         args = self.to_dict([StandardAPIParamsMixin])
-
         results = []
-
+        model = args.pop("model")
         for instance in dataset:
             messages = self.to_messages(instance)
             response = ollama.chat(
-                model=self.model,
                 messages=messages,
-                **args,
+                model=model,
+                options=args,
             )
             results.append(response)
 
@@ -1610,34 +1634,52 @@ class OpenAiInferenceEngine(
 
     @run_with_imap
     def _get_chat_completion(self, instance, return_meta_data):
+        import openai
         messages = self.to_messages(instance)
-        response = self.client.chat.completions.create(
-            messages=messages,
-            model=self.model_name,
-            **self._get_completion_kwargs(),
-        )
-        prediction = response.choices[0].message.content
-        return self.get_return_object(prediction, response, return_meta_data)
+        try:
+            response = self.client.chat.completions.create(
+                messages=messages,
+                model=self.model_name,
+                **self._get_completion_kwargs(),
+            )
+            prediction = response.choices[0].message.content
+            return self.get_return_object(prediction, response, return_meta_data)
+        # catch in case of content_filtering failure
+        except openai.BadRequestError as e:
+            logging.error(f"Error predicting instance {messages}:{e}. Returning empty prediction")
+            return TextGenerationInferenceOutput(prediction = "-", input_tokens=0, output_tokens=0)
+
 
     @run_with_imap
     def _get_logprobs(self, instance, return_meta_data):
+        import openai
         messages = self.to_messages(instance)
-        response = self.client.chat.completions.create(
-            messages=messages,
-            model=self.model_name,
-            **self._get_completion_kwargs(),
-        )
-        top_logprobs_response = response.choices[0].logprobs.content
-        pred_output = [
-            {
-                "top_tokens": [
-                    {"text": obj.token, "logprob": obj.logprob}
-                    for obj in generated_token.top_logprobs
-                ]
-            }
-            for generated_token in top_logprobs_response
-        ]
-        return self.get_return_object(pred_output, response, return_meta_data)
+        try:
+            response = self.client.chat.completions.create(
+                messages=messages,
+                model=self.model_name,
+                **self._get_completion_kwargs(),
+            )
+            top_logprobs_response = response.choices[0].logprobs.content
+            pred_output = [
+                {
+                    "top_tokens": [
+                        {"text": obj.token, "logprob": obj.logprob}
+                        for obj in generated_token.top_logprobs
+                    ]
+                }
+                for generated_token in top_logprobs_response
+            ]
+            return self.get_return_object(pred_output, response, return_meta_data)
+        # catch in case of content_filtering failure
+        except openai.BadRequestError as e:
+            logging.error(f"Error predicting instance {messages}:{e}. Returning empty prediction")
+            prediction = [{"top_tokens": [
+                        {"text": "-", "logprob": 0}
+                    ]
+            }]
+            return TextGenerationInferenceOutput(prediction=prediction, input_tokens=0, output_tokens=0)
+
 
     def get_return_object(self, predict_result, response, return_meta_data):
         if return_meta_data:
@@ -1887,7 +1929,7 @@ class WMLGenerationParamsMixin(Artifact):
 
 class WMLChatParamsMixin(Artifact):
     frequency_penalty: Optional[float] = None
-    top_logprobs: Optional[int] = 5
+    top_logprobs: Optional[int] = None
     presence_penalty: Optional[float] = None
     response_format: Optional[Dict[str, Any]] = None
     temperature: Optional[float] = None
@@ -1898,7 +1940,7 @@ class WMLChatParamsMixin(Artifact):
 
 
 CredentialsWML = Dict[
-    Literal["url", "username", "password", "apikey", "project_id", "space_id"], str
+    Literal["url", "username", "password", "api_key", "project_id", "space_id"], str
 ]
 
 
@@ -1958,28 +2000,28 @@ class WMLInferenceEngineBase(
             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."
 
-    def process_data_before_dump(self, data):
-        if "credentials" in data:
-            for key, value in data["credentials"].items():
-                if key != "url":
-                    data["credentials"][key] = "<hidden>"
-                else:
-                    data["credentials"][key] = value
-        return data
+    # def process_data_before_dump(self, data):
+    #     if "credentials" in data:
+    #         for key, value in data["credentials"].items():
+    #             if key != "url":
+    #                 data["credentials"][key] = "<hidden>"
+    #             else:
+    #                 data["credentials"][key] = value
+    #     return data
 
     def _initialize_wml_client(self):
-        from ibm_watsonx_ai.client import APIClient
+        from ibm_watsonx_ai.client import APIClient, Credentials
 
-        if self.credentials is None:
+        if self.credentials is None or len(self.credentials) == 0:  # TODO: change
             self.credentials = self._read_wml_credentials_from_env()
         self._verify_wml_credentials(self.credentials)
-
-        client = APIClient(credentials=self.credentials)
-        if "space_id" in self.credentials:
-            client.set.default_space(self.credentials["space_id"])
-        else:
-            client.set.default_project(self.credentials["project_id"])
-        return client
+        return APIClient(
+            credentials=Credentials(
+                api_key=self.credentials["api_key"],
+                url=self.credentials["url"]
+            ),
+            project_id=self.credentials.get("project_id", None),
+            space_id=self.credentials.get("space_id", None))
 
     @staticmethod
     def _read_wml_credentials_from_env() -> CredentialsWML:
@@ -2002,6 +2044,8 @@ class WMLInferenceEngineBase(
                 "only one of those defined in the env."
             )
             credentials["space_id"] = space_id
+        elif space_id:
+            credentials["space_id"] = space_id
         elif project_id:
             credentials["project_id"] = project_id
         else:
@@ -2024,7 +2068,7 @@ class WMLInferenceEngineBase(
             )
 
         if apikey:
-            credentials["apikey"] = apikey
+            credentials["api_key"] = apikey
         elif username and password:
             credentials["username"] = username
             credentials["password"] = password
@@ -2042,7 +2086,7 @@ class WMLInferenceEngineBase(
         assert isoftype(credentials, CredentialsWML), (
             "WML credentials object must be a dictionary which may "
             "contain only the following keys: "
-            "['url', 'apikey', 'username', 'password']."
+            "['url', 'api_key', 'username', 'password']."
         )
 
         assert credentials.get(
@@ -2052,10 +2096,10 @@ class WMLInferenceEngineBase(
             "Either 'space_id' or 'project_id' must be provided "
             "as keys for WML credentials dict."
         )
-        assert "apikey" in credentials or (
+        assert "api_key" in credentials or (
             "username" in credentials and "password" in credentials
         ), (
-            "Either 'apikey' or both 'username' and 'password' must be provided "
+            "Either 'api_key' or both 'username' and 'password' must be provided "
             "as keys for WML credentials dict."
         )
 
@@ -2229,7 +2273,8 @@ class WMLInferenceEngineGeneration(WMLInferenceEngineBase, WMLGenerationParamsMi
         # currently this is the only configuration that returns generated
         # logprobs and behaves as expected
         logprobs_return_options = {
-            "input_tokens": True,
+            "input_tokens": user_return_options.get("input_tokens", True),
+            "input_text": user_return_options.get("input_text", False),
             "generated_tokens": True,
             "token_logprobs": True,
             "top_n_tokens": user_return_options.get("top_n_tokens", 5),
@@ -2346,7 +2391,9 @@ class WMLInferenceEngineChat(WMLInferenceEngineBase, WMLChatParamsMixin):
             results = wml_inference.infer(dataset["test"])
     """
 
-    image_encoder: Optional[EncodeImageToString] = None
+    image_encoder: Optional[EncodeImageToString] = NonPositionalField(
+        default_factory=EncodeImageToString
+    )
 
     @staticmethod
     def _extract_queries(instance: Dict[str, Any]) -> Tuple[Optional[str], List]:
@@ -2386,21 +2433,26 @@ class WMLInferenceEngineChat(WMLInferenceEngineBase, WMLChatParamsMixin):
             if image is not None:
                 encoded_image = image
                 if not isinstance(encoded_image, str):
+                    image = Image().decode_example(image)
                     if self.image_encoder is None:
                         raise ValueError(
                             "If sending image queries as well, and they are not "
                             "already encoded to base64 strings, you must specify "
                             "the 'image_encoder' to be used."
                         )
-                    encoded_image = self.image_encoder.encode_image_to_base64(image)
+
+                    buffer = io.BytesIO()
+                    image.save(buffer, format=image.format)
+                    image_data_url = ImageDataString(
+                        f"data:image/{image.format.lower()};base64,"
+                        + base64.b64encode(buffer.getvalue()).decode("utf-8")
+                    )
 
                 message["content"].append(
                     {
                         "type": "image_url",
                         "image_url": {
-                            "url": ImageDataString(
-                                "data:image/jpeg;base64," + encoded_image
-                            ),
+                            "url": image_data_url,
                         },
                     }
                 )
@@ -2550,7 +2602,7 @@ class LMMSEvalBaseInferenceEngine(
     model_type: str
     model_args: Dict[str, str]
     batch_size: int = 1
-    image_token = "<image>"
+    image_token: str = "<image>"
 
     _requirements_list = {
         "lmms_eval": "Install llms-eval package using 'pip install lmms-eval==0.2.4'",
@@ -2576,6 +2628,7 @@ class LMMSEvalBaseInferenceEngine(
             {
                 "batch_size": self.batch_size,
                 "device": self.device,
+                "device_map": self.device,
             },
         )
 
@@ -2714,7 +2767,7 @@ class VLLMParamsMixin(Artifact):
     presence_penalty: float = 0.0
     frequency_penalty: float = 0.0
     repetition_penalty: float = 1.0
-    temperature: float = 1.0
+    temperature: float = 0.0
     top_p: float = 1.0
     top_k: int = -1
     min_p: float = 0.0
@@ -2731,13 +2784,21 @@ class VLLMParamsMixin(Artifact):
 
 class VLLMInferenceEngine(InferenceEngine, PackageRequirementsMixin, VLLMParamsMixin):
     def prepare_engine(self):
-        from vllm import LLM, SamplingParams
-
         args = self.to_dict([VLLMParamsMixin])
         args.pop("model")
+        from vllm import LLM, SamplingParams
 
         self.sampling_params = SamplingParams(**args)
-        self.llm = LLM(model=self.model, trust_remote_code=True)
+        self.llm = LLM(
+            model=self.model,
+            device="auto",
+            trust_remote_code=True,
+            max_num_batched_tokens=4096,
+            gpu_memory_utilization=0.7,
+            max_model_len=4096,
+            max_num_seqs=64,
+            enforce_eager=True,
+        )
 
     def _infer(
         self,
@@ -2749,6 +2810,7 @@ class VLLMInferenceEngine(InferenceEngine, PackageRequirementsMixin, VLLMParamsM
             inputs.append(instance["source"])
 
         if isinstance(inputs[0], list):
+            # outputs = self.llm.chat(inputs, self.sampling_params, chat_template="{{- bos_token }}\n{%- if custom_tools is defined %}\n    {%- set tools = custom_tools %}\n{%- endif %}\n{%- if not tools_in_user_message is defined %}\n    {%- set tools_in_user_message = true %}\n{%- endif %}\n{%- if not date_string is defined %}\n    {%- if strftime_now is defined %}\n        {%- set date_string = strftime_now(\"%d %b %Y\") %}\n    {%- else %}\n        {%- set date_string = \"26 Jul 2024\" %}\n    {%- endif %}\n{%- endif %}\n{%- if not tools is defined %}\n    {%- set tools = none %}\n{%- endif %}\n\n{#- This block extracts the system message, so we can slot it into the right place. #}\n{%- if messages[0]['role'] == 'system' %}\n    {%- set system_message = messages[0]['content']|trim %}\n    {%- set messages = messages[1:] %}\n    {%- set user_supplied_system_message = true %}\n{%- else %}\n    {%- set system_message = \"\" %}\n    {%- set user_supplied_system_message = false %}\n{%- endif %}\n\n{#- Find out if there are any images #}\n{% set image_ns = namespace(has_images=false) %}      \n{%- for message in messages %}\n    {%- for content in message['content'] %}\n        {%- if content['type'] == 'image' %}\n            {%- set image_ns.has_images = true %}\n        {%- endif %}\n    {%- endfor %}\n{%- endfor %}\n\n{#- System message if there are no images, or if the user supplied one #}\n{%- if user_supplied_system_message or not image_ns.has_images %}\n    {{- \"<|start_header_id|>system<|end_header_id|>\\n\" }}\n    {%- if tools is not none %}\n        {{- \"Environment: ipython\\n\" }}\n    {%- endif %}\n    {{- \"Cutting Knowledge Date: December 2023\\n\" }}\n    {{- \"Today Date: \" + date_string + \"\\n\" }}\n    {%- if tools is not none and not tools_in_user_message %}\n        {{- \"You have access to the following functions. To call a function, please respond with JSON for a function call.\" }}\n        {{- 'Respond in the format {\"name\": function name, \"parameters\": dictionary of argument name and its value}.' }}\n        {{- \"Do not use variables.\\n\" }}\n        {%- for t in tools %}\n            {{- t | tojson(indent=4) }}\n            {{- \"\\n\" }}\n        {%- endfor %}\n    {%- endif %}\n    {{- system_message }}\n    {{- \"<|eot_id|>\" }}\n{%- endif %}\n\n{#- Custom tools are passed in a user message with some extra guidance #}\n{%- if tools_in_user_message and not tools is none %}\n    {#- Extract the first user message so we can plug it in here #}\n    {%- if messages | length != 0 %}\n        {%- set first_user_message = messages[0]['content']|trim %}\n        {%- set messages = messages[1:] %}\n    {%- else %}\n        {{- raise_exception(\"Cannot put tools in the first user message when there's no first user message!\") }}\n{%- endif %}\n    {{- '<|start_header_id|>user<|end_header_id|>\\n' -}}\n    {{- \"Given the following functions, please respond with a JSON for a function call \" }}\n    {{- \"with its proper arguments that best answers the given prompt.\\n\" }}\n    {{- 'Respond in the format {\"name\": function name, \"parameters\": dictionary of argument name and its value}.' }}\n    {{- \"Do not use variables.\\n\" }}\n    {%- for t in tools %}\n        {{- t | tojson(indent=4) }}\n        {{- \"\\n\" }}\n    {%- endfor %}\n    {{- first_user_message + \"<|eot_id|>\"}}\n{%- endif %}\n\n{%- for message in messages %}\n    {%- if not (message.role == 'ipython' or message.role == 'tool' or 'tool_calls' in message) %}\n    {{- '<|start_header_id|>' + message['role'] + '<|end_header_id|>\\n' }}\n        {%- if message['content'] is string %}\n            {{- message['content'] }}\n        {%- else %}\n            {%- for content in message['content'] %}\n                {%- if content['type'] == 'image' %}\n                    {{- '<|image|>' }}\n                {%- elif content['type'] == 'text' %}\n                    {{- content['text'] }}\n                {%- endif %}\n            {%- endfor %}\n        {%- endif %}\n        {{- '<|eot_id|>' }}\n    {%- elif 'tool_calls' in message %}\n        {%- if not message.tool_calls|length == 1 %}\n            {{- raise_exception(\"This model only supports single tool-calls at once!\") }}\n        {%- endif %}\n        {%- set tool_call = message.tool_calls[0].function %}\n        {{- '<|start_header_id|>assistant<|end_header_id|>\\n' -}}\n        {{- '{\"name\": \"' + tool_call.name + '\", ' }}\n        {{- '\"parameters\": ' }}\n        {{- tool_call.arguments | tojson }}\n        {{- \"}\" }}\n        {{- \"<|eot_id|>\" }}\n    {%- elif message.role == \"tool\" or message.role == \"ipython\" %}\n        {{- \"<|start_header_id|>ipython<|end_header_id|>\\n\" }}\n        {%- if message.content is mapping or message.content is iterable %}\n            {{- message.content | tojson }}\n        {%- else %}\n            {{- message.content }}\n        {%- endif %}\n        {{- \"<|eot_id|>\" }}\n    {%- endif %}\n{%- endfor %}\n{%- if add_generation_prompt %}\n    {{- '<|start_header_id|>assistant<|end_header_id|>\\n' }}\n{%- endif %}")
             outputs = self.llm.chat(inputs, self.sampling_params)
         else:
             outputs = self.llm.generate(inputs, self.sampling_params)
@@ -2862,12 +2924,12 @@ class LiteLLMInferenceEngine(
         self, dataset: List[Dict[str, Any]]
     ) -> List[TextGenerationInferenceOutput]:
         """Process multiple inference requests concurrently with a progress bar."""
-        tasks = [
+        tasks = (
             self._infer_instance(i, instance) for i, instance in enumerate(dataset)
-        ]
+        )
         # Use tqdm_asyncio.gather to display progress bar
         return await tqdm_asyncio.gather(
-            *tasks, desc=f"LiteLLM Inference ({self.model})", total=len(tasks)
+            *tasks, desc=f"LiteLLM Inference ({self.model})", total=len(dataset)
         )
 
     def _infer(
@@ -2923,10 +2985,12 @@ class CrossProviderInferenceEngine(InferenceEngine, StandardAPIParamsMixin):
             mapping each supported API to a corresponding
             model identifier string. This mapping allows consistent access to models
             across different API backends.
+        provider_specific_args: (Optional[Dict[str, Dict[str,str]]]) Args specific to a provider for example provider_specific_args={"watsonx": {"max_requests_per_second": 4}}
     """
 
     label: str = "cross_provider"
     provider: Optional[_supported_apis] = None
+    provider_specific_args: Optional[Dict[str, Dict[str,str]]] = None
 
     provider_model_map: Dict[_supported_apis, Dict[str, str]] = {
         "watsonx": {
@@ -2939,8 +3003,10 @@ class CrossProviderInferenceEngine(InferenceEngine, StandardAPIParamsMixin):
             "llama-3-2-1b-instruct": "watsonx/meta-llama/llama-3-2-1b-instruct",
             "llama-3-2-11b-vision-instruct": "watsonx/meta-llama/llama-3-2-11b-vision-instruct",
             "llama-3-2-90b-vision-instruct": "watsonx/meta-llama/llama-3-2-90b-vision-instruct",
+            "mistral-large-instruct": "watsonx/mistralai/mistral-large",
         },
         "watsonx-sdk": {
+            "llama-3-2-11b-vision-instruct": "meta-llama/llama-3-2-11b-vision-instruct",
             "llama-3-8b-instruct": "meta-llama/llama-3-8b-instruct",
             "llama-3-70b-instruct": "meta-llama/llama-3-70b-instruct",
             "granite-3-8b-instruct": "ibm/granite-3-8b-instruct",
@@ -3084,12 +3150,18 @@ class CrossProviderInferenceEngine(InferenceEngine, StandardAPIParamsMixin):
                 f"{provider} is not a configured API for CrossProviderInferenceEngine. Supported apis: {','.join(self.provider_model_map.keys())}"
             )
         if self.model not in self.provider_model_map[provider]:
-            raise UnitxtError(
-                f"{self.model} is not configured for provider {provider}. Supported models: {','.join(self.provider_model_map[provider].keys())}"
+            UnitxtWarning(
+                f"{self.model} is not configured for provider {provider}. Supported models: {','.join(self.provider_model_map[provider].keys())}. Using un normalized name will make it impossible to switch to different provider on request."
             )
         cls = self.__class__._provider_to_base_class[provider]
         args = self.to_dict([StandardAPIParamsMixin])
-        args["model"] = self.provider_model_map[provider][self.model]
+        args["model"] = self.provider_model_map[provider].get(self.model, self.model)
+
+        if self.provider_specific_args is not None:
+            provider_args =  self.provider_specific_args.get(provider)
+            if provider_args is not None:
+                args.update(provider_args)
+
         params = list(args.keys())
         if provider in self._provider_param_renaming:
             for param in params:
@@ -3135,8 +3207,16 @@ class HFOptionSelectingInferenceEngine(InferenceEngine, TorchDeviceMixin):
         self.device = self.get_device()
 
         # Load model and tokenizer
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
-        self.model = AutoModelForCausalLM.from_pretrained(self.model_name).to(
+        path = self.model_name
+        if settings.hf_offline_models_path is not None:
+            path = os.path.join(settings.hf_offline_models_path, path)
+
+        self.tokenizer = AutoTokenizer.from_pretrained(
+            path,
+        )
+        self.model = AutoModelForCausalLM.from_pretrained(
+                path,
+            ).to(
             self.device
         )
         # Set pad_token if it doesn't exist

llm_as_judge_chat_templates.py

@@ -8,14 +8,19 @@ The context includes information relevant to the nature or generation of the res
 You will assess the quality of the response subject to an evaluation criteria.
 ###Context:
 {context_variables}
+
 ###Response:
 {response}
+
 ###Evaluation criteria:
 {criteria_description}
 {display_options_instruction}
+
 Briefly assess the quality of the response subject to the evaluation criteria.
 Focus on the evaluation criteria during assessment, do not provide a general assessment.
-Assessment: """
+Assessment:
+
+Lets think step by step """
     ),
     "summarization": InputOutputTemplate(
         input_format="""Transform the following assessment into a concise summary that focuses on the key details, excluding references to the assessment itself.
@@ -41,9 +46,11 @@ You will choose the better quality response subject to the evaluation criteria.
 
 This is the context:
 {context_variables}
+
 This is the evaluation criteria:
 {criteria_name}
 {criteria_description}
+
 Response {option_a}:
 {response_a}
 Response {option_b}:
@@ -51,7 +58,9 @@ Response {option_b}:
 
 Keeping the evaluation criteria in mind, briefly assess which response is better.
 Focus on the evaluation criteria during assessment, do not provide a general assessment.
-Assessment: """
+Assessment:
+
+Lets think step by step """
     ),
     "summarization": InputOutputTemplate(
         input_format="""Transform the following assessment into a concise summary that focuses on the key details, excluding references to the assessment itself. The summary must clearly state which response won.

llm_as_judge_constants.py

@@ -84,8 +84,6 @@ class EvaluatorNameEnum(str, Enum):
     GRANITE3_8B = "Granite3.0-8b"
     GRANITE3_1_2B = "Granite3.1-2b"
     GRANITE3_1_8B = "Granite3.1-8b"
-    GRANITE_GUARDIAN_2B = "Granite Guardian 3.0 2B"
-    GRANITE_GUARDIAN_8B = "Granite Guardian 3.0 8B"
 
 
 class ModelProviderEnum(str, Enum):
@@ -112,8 +110,6 @@ EVALUATOR_TO_MODEL_ID = {
     EvaluatorNameEnum.GRANITE3_8B: "ibm/granite-3-8b-instruct",
     EvaluatorNameEnum.GRANITE3_1_2B: "ibm/granite-3.1-2b-instruct",
     EvaluatorNameEnum.GRANITE3_1_8B: "ibm/granite-3.1-8b-instruct",
-    EvaluatorNameEnum.GRANITE_GUARDIAN_2B: "ibm/granite-guardian-3-2b",
-    EvaluatorNameEnum.GRANITE_GUARDIAN_8B: "ibm/granite-guardian-3-8b",
 }
 
 MODEL_RENAMINGS = {
@@ -189,14 +185,6 @@ EVALUATORS_METADATA = [
         EvaluatorNameEnum.LLAMA3_1_405B,
         [ModelProviderEnum.WATSONX, ModelProviderEnum.RITS],
     ),
-    EvaluatorMetadata(
-        EvaluatorNameEnum.GRANITE_GUARDIAN_2B,
-        [ModelProviderEnum.WATSONX],
-    ),
-    EvaluatorMetadata(
-        EvaluatorNameEnum.GRANITE_GUARDIAN_8B,
-        [ModelProviderEnum.WATSONX],
-    ),
 ]
 
 ################################  Direct Assessment Criterias ################################
@@ -946,6 +934,30 @@ class DirectCriteriaCatalogEnum(Enum):
         },
     )
 
+    CORRECTNESS_BASED_ON_GROUND_TRUTH = CriteriaWithOptions(
+        name="correctness_based_on_ground_truth",
+        description="Does the response correctly convey the same factual information as the ground truth?",
+        options=[
+            CriteriaOption(
+                name="correct",
+                description="The response conveys the same factual meaning as the ground truth. Minor rewording, synonyms, or grammatical differences are acceptable. The response is relevant to the question and does not introduce unrelated or misleading information.",
+            ),
+            CriteriaOption(
+                name="partially_correct",
+                description="The response contains some correct information but is incomplete or lacks essential details. It may also contain minor inaccuracies or extraneous information that slightly misrepresents the ground truth.",
+            ),
+            CriteriaOption(
+                name="incorrect",
+                description="The response does not align with the ground truth. It either presents incorrect, unrelated, or misleading information, or omits key details that change the intended meaning.",
+            ),
+        ],
+        option_map={
+            "correct": 1.0,
+            "partially_correct": 0.5,
+            "incorrect": 0.0,
+        },
+    )
+
 
 DIRECT_CRITERIA = [c.value for c in DirectCriteriaCatalogEnum]
 

llm_as_judge_from_template.py

@@ -459,12 +459,12 @@ class TaskBasedLLMasJudge(LLMAsJudgeBase):
                     judge_task_input_field, judge_task_input_field
                 )
                 new_val = input_instance.get(orig_task_field_name)
-                if not new_val and isinstance(prediction, dict):
+                if new_val is None and isinstance(prediction, dict):
                     new_val = prediction.get(orig_task_field_name)
-                if new_val:
+                if new_val is not None:
                     instance_task_data[judge_task_input_field] = new_val
 
-            if self.prediction_field and prediction:
+            if self.prediction_field and prediction is not None:
                 if isinstance(prediction, dict):
                     prediction = prediction[self.prediction_field]
                 instance_task_data[self.prediction_field] = prediction

loaders.py

@@ -36,12 +36,14 @@ import itertools
 import json
 import os
 import tempfile
+import time
 from abc import abstractmethod
 from pathlib import Path
 from tempfile import TemporaryDirectory
 from typing import (
     Any,
     Dict,
+    Generator,
     Iterable,
     List,
     Literal,
@@ -53,24 +55,44 @@ from typing import (
 
 import pandas as pd
 import requests
-from datasets import DatasetDict, IterableDatasetDict
-from datasets import load_dataset as hf_load_dataset
+from datasets import (
+    DatasetDict,
+    DownloadConfig,
+    IterableDataset,
+    IterableDatasetDict,
+    get_dataset_split_names,
+)
+from datasets import load_dataset as _hf_load_dataset
 from huggingface_hub import HfApi
 from tqdm import tqdm
 
-from .dataclass import OptionalField
+from .dataclass import NonPositionalField
+from .error_utils import UnitxtError, UnitxtWarning
 from .fusion import FixedFusion
 from .logging_utils import get_logger
 from .operator import SourceOperator
 from .operators import Set
 from .settings_utils import get_settings
-from .stream import MultiStream
+from .stream import DynamicStream, MultiStream
 from .type_utils import isoftype
-from .utils import LRUCache
+from .utils import LRUCache, recursive_copy
 
 logger = get_logger()
 settings = get_settings()
 
+def hf_load_dataset(path: str, *args, **kwargs):
+    if settings.hf_offline_datasets_path is not None:
+        path = os.path.join(settings.hf_offline_datasets_path, path)
+    return _hf_load_dataset(
+        path,
+        *args, **kwargs,
+            download_config=DownloadConfig(
+                max_retries=settings.loaders_max_retries,
+            ),
+            verification_mode="no_checks",
+            trust_remote_code=settings.allow_unverified_code,
+            download_mode= "force_redownload" if settings.disable_hf_datasets_cache else "reuse_dataset_if_exists"
+        )
 
 class Loader(SourceOperator):
     """A base class for all loaders.
@@ -114,9 +136,11 @@ class Loader(SourceOperator):
         return f"{self.__class__.__name__}.loader_limit"
 
     def log_limited_loading(self):
-        logger.info(
-            f"\nLoading limited to {self.get_limit()} instances by setting {self.get_limiter()};"
-        )
+        if not hasattr(self, "_already_logged_limited_loading") or not self._already_logged_limited_loading:
+            self._already_logged_limited_loading = True
+            logger.info(
+                f"\nLoading limited to {self.get_limit()} instances by setting {self.get_limiter()};"
+            )
 
     def add_data_classification(self, multi_stream: MultiStream) -> MultiStream:
         if self.data_classification_policy is None:
@@ -156,19 +180,46 @@ class Loader(SourceOperator):
         pass
 
     def load_data(self) -> MultiStream:
-        iterables = self.__class__._loader_cache.get(str(self), None)
-        if iterables is None:
+        try:
             iterables = self.load_iterables()
-            self.__class__._loader_cache.max_size = settings.loader_cache_size
-            self.__class__._loader_cache[str(self)] = iterables
+        except Exception as e:
+            raise UnitxtError(f"Error in loader:\n{self}") from e
+        if isoftype(iterables, MultiStream):
+            return iterables
         return MultiStream.from_iterables(iterables, copying=True)
 
     def process(self) -> MultiStream:
         self._maybe_set_classification_policy()
         return self.add_data_classification(self.load_data())
 
+    def get_splits(self):
+        return list(self().keys())
+
+
+class LazyLoader(Loader):
+    split: Optional[str] = NonPositionalField(default=None)
+
+    @abstractmethod
+    def get_splits(self) -> List[str]:
+        pass
 
-class LoadHF(Loader):
+    @abstractmethod
+    def split_generator(self, split: str) -> Generator:
+        pass
+
+    def load_iterables(self) -> Union[Dict[str, DynamicStream], IterableDatasetDict]:
+        if self.split is not None:
+            splits = [self.split]
+        else:
+            splits = self.get_splits()
+
+        return MultiStream({
+            split: DynamicStream(self.split_generator, gen_kwargs={"split": split})
+            for split in splits
+        })
+
+
+class LoadHF(LazyLoader):
     """Loads datasets from the HuggingFace Hub.
 
     It supports loading with or without streaming,
@@ -213,13 +264,7 @@ class LoadHF(Loader):
     streaming: bool = None
     filtering_lambda: Optional[str] = None
     num_proc: Optional[int] = None
-    requirements_list: List[str] = OptionalField(default_factory=list)
-
-    def verify(self):
-        for requirement in self.requirements_list:
-            if requirement not in self._requirements_list:
-                self._requirements_list.append(requirement)
-        super().verify()
+    splits: Optional[List[str]] = None
 
     def filter_load(self, dataset: DatasetDict):
         if not settings.allow_unverified_code:
@@ -234,12 +279,15 @@ class LoadHF(Loader):
             return settings.stream_hf_datasets_by_default
         return self.streaming
 
-    def stream_dataset(self):
-        with tempfile.TemporaryDirectory() as dir_to_be_deleted:
-            if settings.disable_hf_datasets_cache and not self.is_streaming():
-                cache_dir = dir_to_be_deleted
-            else:
-                cache_dir = None
+    # returns Dict when split names are not known in advance, and just the the single split dataset - if known
+    def load_dataset(
+        self, split: str, streaming=None, disable_memory_caching=False
+    ) -> Union[IterableDatasetDict, IterableDataset]:
+        dataset_id = str(self) + "_" + str(split)
+        dataset = self.__class__._loader_cache.get(dataset_id, None)
+        if dataset is None:
+            if streaming is None:
+                streaming = self.is_streaming()
             try:
                 dataset = hf_load_dataset(
                     self.path,
@@ -247,44 +295,8 @@ class LoadHF(Loader):
                     data_dir=self.data_dir,
                     data_files=self.data_files,
                     revision=self.revision,
-                    streaming=self.is_streaming(),
-                    cache_dir=cache_dir,
-                    split=self.split,
-                    trust_remote_code=settings.allow_unverified_code,
-                    num_proc=self.num_proc,
-                )
-            except ValueError as e:
-                if "trust_remote_code" in str(e):
-                    raise ValueError(
-                        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
-                raise e
-
-        if self.split is not None:
-            dataset = {self.split: dataset}
-
-        if self.filtering_lambda is not None:
-            dataset = self.filter_load(dataset)
-
-        return dataset
-
-    def load_dataset(self):
-        with tempfile.TemporaryDirectory() as dir_to_be_deleted:
-            if settings.disable_hf_datasets_cache:
-                cache_dir = dir_to_be_deleted
-            else:
-                cache_dir = None
-            try:
-                dataset = hf_load_dataset(
-                    self.path,
-                    name=self.name,
-                    data_dir=self.data_dir,
-                    data_files=self.data_files,
-                    streaming=False,
-                    keep_in_memory=True,
-                    cache_dir=cache_dir,
-                    split=self.split,
-                    trust_remote_code=settings.allow_unverified_code,
+                    streaming=streaming,
+                    split=split,
                     num_proc=self.num_proc,
                 )
             except ValueError as e:
@@ -292,11 +304,10 @@ class LoadHF(Loader):
                     raise ValueError(
                         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.split is not None:
-            dataset = {self.split: dataset}
-
-        return dataset
+            self.__class__._loader_cache.max_size = settings.loader_cache_size
+            if not disable_memory_caching:
+                self.__class__._loader_cache[dataset_id] = dataset
+        return self.__class__._loader_cache[dataset_id]
 
     def _maybe_set_classification_policy(self):
         if os.path.exists(self.path):
@@ -309,34 +320,57 @@ class LoadHF(Loader):
                 None,  # No warning when loading from public hub
             )
 
-    def load_iterables(self) -> IterableDatasetDict:
+    def get_splits(self):
+        if self.splits is not None:
+            return self.splits
+        try:
+            return get_dataset_split_names(
+                path=self.path,
+                config_name=self.name,
+                trust_remote_code=settings.allow_unverified_code,
+                download_config=DownloadConfig(
+                    max_retries=settings.loaders_max_retries,
+                    extract_on_the_fly=True,
+                ),
+            )
+        except:
+            UnitxtWarning(
+                f'LoadHF(path="{self.path}", name="{self.name}") could not retrieve split names without loading the dataset. Consider defining "splits" in the LoadHF definition to improve loading time.'
+            )
+            try:
+                dataset = self.load_dataset(
+                    split=None, disable_memory_caching=True, streaming=True
+                )
+            except (
+                NotImplementedError
+            ):  # streaming is not supported for zipped files so we load without streaming
+                dataset = self.load_dataset(split=None, streaming=False)
+            return list(dataset.keys())
+
+    def split_generator(self, split: str) -> Generator:
+        if self.get_limit() is not None:
+            self.log_limited_loading()
         try:
-            dataset = self.stream_dataset()
+            dataset = self.load_dataset(split=split)
         except (
             NotImplementedError
         ):  # streaming is not supported for zipped files so we load without streaming
-            dataset = self.load_dataset()
+            dataset = self.load_dataset(split=split, streaming=False)
 
         if self.filtering_lambda is not None:
             dataset = self.filter_load(dataset)
 
         limit = self.get_limit()
-        if limit is not None:
-            self.log_limited_loading()
-            result = {}
-            for split_name in dataset:
-                try:
-                    split_limit = min(limit, len(dataset[split_name]))
-                except:
-                    split_limit = limit
-                result[split_name] = dataset[split_name].take(split_limit)
-
-            return result
-
-        return dataset
+        if limit is None:
+            yield from dataset
+        else:
+            for i, instance in enumerate(dataset):
+                yield instance
+                if i + 1 >= limit:
+                    break
 
 
-class LoadCSV(Loader):
+class LoadCSV(LazyLoader):
     """Loads data from CSV files.
 
     Supports streaming and can handle large files by loading them in chunks.
@@ -381,6 +415,7 @@ class LoadCSV(Loader):
         args = {}
         if self.file_type == "csv":
             args["sep"] = self.sep
+            args["low_memory"] = self.streaming
         if self.compression is not None:
             args["compression"] = self.compression
         if self.lines is not None:
@@ -389,19 +424,44 @@ class LoadCSV(Loader):
             args["nrows"] = self.get_limit()
         return args
 
-    def load_iterables(self):
-        iterables = {}
-        for split_name, file_path in self.files.items():
-            reader = self.get_reader()
+    def get_splits(self) -> List[str]:
+        return list(self.files.keys())
+
+    def split_generator(self, split: str) -> Generator:
+        dataset_id = str(self) + "_" + split
+        dataset = self.__class__._loader_cache.get(dataset_id, None)
+        if dataset is None:
             if self.get_limit() is not None:
                 self.log_limited_loading()
-            iterables[split_name] = reader(file_path, **self.get_args()).to_dict(
-                "records"
-            )
-        return iterables
+            for attempt in range(settings.loaders_max_retries):
+                try:
+                    reader = self.get_reader()
+                    if self.get_limit() is not None:
+                        self.log_limited_loading()
+
+                    try:
+                        dataset = reader(self.files[split], **self.get_args()).to_dict(
+                            "records"
+                        )
+                    except ValueError:
+                        import fsspec
+
+                        with fsspec.open(self.files[split], mode="rt") as f:
+                            dataset = reader(f, **self.get_args()).to_dict("records")
+                except Exception as e:
+                    logger.debug(f"Attempt csv load {attempt + 1} failed: {e}")
+                    if attempt < settings.loaders_max_retries - 1:
+                        time.sleep(2)
+                    else:
+                        raise e
+            self.__class__._loader_cache.max_size = settings.loader_cache_size
+            self.__class__._loader_cache[dataset_id] = dataset
+
+        for instance in self.__class__._loader_cache[dataset_id]:
+            yield recursive_copy(instance)
 
 
-class LoadFromSklearn(Loader):
+class LoadFromSklearn(LazyLoader):
     """Loads datasets from the sklearn library.
 
     This loader does not support streaming and is intended for use with sklearn's dataset fetch functions.
@@ -437,15 +497,22 @@ class LoadFromSklearn(Loader):
 
         self.downloader = getattr(sklearn_datatasets, f"fetch_{self.dataset_name}")
 
-    def load_iterables(self):
-        with TemporaryDirectory() as temp_directory:
-            for split in self.splits:
-                split_data = self.downloader(subset=split)
-                targets = [split_data["target_names"][t] for t in split_data["target"]]
-                df = pd.DataFrame([split_data["data"], targets]).T
-                df.columns = ["data", "target"]
-                df.to_csv(os.path.join(temp_directory, f"{split}.csv"), index=None)
-            return hf_load_dataset(temp_directory, streaming=False)
+    def get_splits(self):
+        return self.splits
+
+    def split_generator(self, split: str) -> Generator:
+        dataset_id = str(self) + "_" + split
+        dataset = self.__class__._loader_cache.get(dataset_id, None)
+        if dataset is None:
+            split_data = self.downloader(subset=split)
+            targets = [split_data["target_names"][t] for t in split_data["target"]]
+            df = pd.DataFrame([split_data["data"], targets]).T
+            df.columns = ["data", "target"]
+            dataset = df.to_dict("records")
+            self.__class__._loader_cache.max_size = settings.loader_cache_size
+            self.__class__._loader_cache[dataset_id] = dataset
+        for instance in self.__class__._loader_cache[dataset_id]:
+            yield recursive_copy(instance)
 
 
 class MissingKaggleCredentialsError(ValueError):
@@ -683,7 +750,7 @@ class LoadFromIBMCloud(Loader):
         return dataset
 
 
-class MultipleSourceLoader(Loader):
+class MultipleSourceLoader(LazyLoader):
     """Allows loading data from multiple sources, potentially mixing different types of loaders.
 
     Args:
@@ -707,20 +774,23 @@ class MultipleSourceLoader(Loader):
 
     sources: List[Loader]
 
-    # MultipleSourceLoaders uses the the data classification from source loaders,
-    # so only need to add it, if explicitly requested to override.
     def add_data_classification(self, multi_stream: MultiStream) -> MultiStream:
         if self.data_classification_policy is None:
             return multi_stream
         return super().add_data_classification(multi_stream)
 
-    def load_iterables(self):
-        pass
+    def get_splits(self):
+        splits = []
+        for loader in self.sources:
+            splits.extend(loader.get_splits())
+        return list(set(splits))
 
-    def load_data(self):
-        return FixedFusion(
-            subsets=self.sources, max_instances_per_subset=self.get_limit()
-        ).process()
+    def split_generator(self, split: str) -> Generator[Any, None, None]:
+        yield from FixedFusion(
+            subsets=self.sources,
+            max_instances_per_subset=self.get_limit(),
+            include_splits=[split],
+        )()[split]
 
 
 class LoadFromDictionary(Loader):
@@ -775,11 +845,8 @@ class LoadFromDictionary(Loader):
         return self.data
 
 
-class LoadFromHFSpace(LoadHF):
-    """Used to load data from HuggingFace Spaces.
-
-    Loaders firstly tries to download all files specified in the 'data_files' parameter
-    from the given space and then reads them as a HuggingFace Dataset.
+class LoadFromHFSpace(LazyLoader):
+    """Used to load data from HuggingFace Spaces lazily.
 
     Args:
         space_name (str):
@@ -800,22 +867,6 @@ class LoadFromHFSpace(LoadHF):
         token_env (str, optional):
             Key of an env variable which value will be used for
             authentication when accessing the HuggingFace Space - if necessary.
-
-    Example:
-        Loading from a HuggingFace Space
-
-        .. code-block:: python
-
-            loader = LoadFromHFSpace(
-                space_name="lmsys/mt-bench",
-                data_files={
-                    "train": [
-                        "data/mt_bench/model_answer/gpt-3.5-turbo.jsonl",
-                        "data/mt_bench/model_answer/gpt-4.jsonl",
-                    ],
-                    "test": "data/mt_bench/model_answer/tulu-30b.jsonl",
-                },
-            )
     """
 
     space_name: str
@@ -840,123 +891,78 @@ class LoadFromHFSpace(LoadHF):
             return token
         return self.use_token
 
-    def _download_file_from_space(self, filename: str) -> str:
-        from huggingface_hub import hf_hub_download
-        from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
+    @staticmethod
+    def _is_wildcard(path: str) -> bool:
+        wildcard_characters = ["*", "?", "[", "]"]
+        return any(char in path for char in wildcard_characters)
 
-        token = self._get_token()
 
-        try:
-            file_path = hf_hub_download(
-                repo_id=self.space_name,
-                filename=filename,
-                repo_type="space",
-                token=token,
-                revision=self.revision,
-                local_dir=self.path,
+
+    def _get_repo_files(self):
+        if not hasattr(self, "_repo_files") or self._repo_files is None:
+            api = HfApi()
+            self._repo_files = api.list_repo_files(
+                self.space_name, repo_type="space", revision=self.revision
             )
-        except EntryNotFoundError as e:
-            raise ValueError(
-                f"The file '{filename}' was not found in the space '{self.space_name}'. "
-                f"Please check if the filename is correct, or if it exists in that "
-                f"Huggingface space."
-            ) from e
-        except RepositoryNotFoundError as e:
-            raise ValueError(
-                f"The Huggingface space '{self.space_name}' was not found. "
-                f"Please check if the name is correct and you have access to the space."
-            ) from e
+        return self._repo_files
 
-        return file_path
+    def _get_sub_files(self, file: str) -> List[str]:
+        if self._is_wildcard(file):
+            return fnmatch.filter(self._get_repo_files(), file)
+        return [file]
 
-    def _download_data(self) -> str:
-        if isinstance(self.data_files, str):
-            data_files = [self.data_files]
-        elif isinstance(self.data_files, Mapping):
-            data_files = list(self.data_files.values())
-        else:
-            data_files = self.data_files
 
-        dir_paths_list = []
-        for files in data_files:
-            if isinstance(files, str):
-                files = [files]
+    def get_splits(self) -> List[str]:
+        if isinstance(self.data_files, Mapping):
+            return list(self.data_files.keys())
+        return ["train"]  # Default to 'train' if not specified
 
-            paths = [self._download_file_from_space(file) for file in files]
-            dir_paths = [
-                path.replace(file_url, "") for path, file_url in zip(paths, files)
-            ]
-            dir_paths_list.extend(dir_paths)
+    def split_generator(self, split: str) -> Generator:
+        from huggingface_hub import hf_hub_download
+        from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
 
-        # All files - within the same space - are downloaded into the same base directory:
-        assert len(set(dir_paths_list)) == 1
+        token = self._get_token()
+        files = self.data_files.get(split, self.data_files) if isinstance(self.data_files, Mapping) else self.data_files
 
-        return f"{dir_paths_list.pop()}"
+        if isinstance(files, str):
+            files = [files]
+        limit = self.get_limit()
 
-    @staticmethod
-    def _is_wildcard(path: str) -> bool:
-        wildcard_characters = ["*", "?", "[", "]"]
-        return any(char in path for char in wildcard_characters)
+        if limit is not None:
+            total = 0
+            self.log_limited_loading()
 
-    def _get_file_list_from_wildcard_path(
-        self, pattern: str, repo_files: List
-    ) -> List[str]:
-        if self._is_wildcard(pattern):
-            return fnmatch.filter(repo_files, pattern)
-        return [pattern]
-
-    def _map_wildcard_path_to_full_paths(self):
-        api = HfApi()
-        repo_files = api.list_repo_files(
-            self.space_name, repo_type="space", revision=self.revision
-        )
-        if isinstance(self.data_files, str):
-            self.data_files = self._get_file_list_from_wildcard_path(
-                self.data_files, repo_files
-            )
-        elif isinstance(self.data_files, Mapping):
-            new_mapping = {}
-            for k, v in self.data_files.items():
-                if isinstance(v, list):
-                    assert all(isinstance(s, str) for s in v)
-                    new_mapping[k] = [
-                        file
-                        for p in v
-                        for file in self._get_file_list_from_wildcard_path(
-                            p, repo_files
-                        )
-                    ]
-                elif isinstance(v, str):
-                    new_mapping[k] = self._get_file_list_from_wildcard_path(
-                        v, repo_files
-                    )
-                else:
-                    raise NotImplementedError(
-                        f"Loader does not support input 'data_files' of type Mapping[{type(v)}]"
+        for file in files:
+            for sub_file in self._get_sub_files(file):
+                try:
+                    file_path = hf_hub_download(
+                        repo_id=self.space_name,
+                        filename=sub_file,
+                        repo_type="space",
+                        token=token,
+                        revision=self.revision,
+                        local_dir=self.path,
                     )
+                except EntryNotFoundError as e:
+                    raise ValueError(
+                        f"The file '{file}' was not found in the space '{self.space_name}'. "
+                        f"Please check if the filename is correct, or if it exists in that "
+                        f"Huggingface space."
+                    ) from e
+                except RepositoryNotFoundError as e:
+                    raise ValueError(
+                        f"The Huggingface space '{self.space_name}' was not found. "
+                        f"Please check if the name is correct and you have access to the space."
+                    ) from e
 
-            self.data_files = new_mapping
-        elif isinstance(self.data_files, list):
-            assert all(isinstance(s, str) for s in self.data_files)
-            self.data_files = [
-                file
-                for p in self.data_files
-                for file in self._get_file_list_from_wildcard_path(p, repo_files)
-            ]
-        else:
-            raise NotImplementedError(
-                f"Loader does not support input 'data_files' of type {type(self.data_files)}"
-            )
-
-    def _maybe_set_classification_policy(self):
-        self.set_default_data_classification(
-            ["public"], "when loading from Huggingface spaces"
-        )
+                with open(file_path, encoding="utf-8") as f:
+                    for line in f:
+                        yield json.loads(line.strip())
+                        if limit is not None:
+                            total += 1
+                            if total >= limit:
+                                return
 
-    def load_data(self):
-        self._map_wildcard_path_to_full_paths()
-        self.path = self._download_data()
-        return super().load_data()
 
 
 class LoadFromAPI(Loader):
@@ -985,6 +991,9 @@ class LoadFromAPI(Loader):
             Defaults to "data".
         method (str, optional):
             The HTTP method to use for API requests. Defaults to "GET".
+        verify_cert (bool):
+            Apply verification of the SSL certificate
+            Defaults as True
     """
 
     urls: Dict[str, str]
@@ -995,6 +1004,7 @@ class LoadFromAPI(Loader):
     headers: Optional[Dict[str, Any]] = None
     data_field: str = "data"
     method: str = "GET"
+    verify_cert: bool = True
 
     # class level shared cache:
     _loader_cache = LRUCache(max_size=settings.loader_cache_size)
@@ -1026,13 +1036,13 @@ class LoadFromAPI(Loader):
                 response = requests.get(
                     url,
                     headers=base_headers,
-                    verify=True,
+                    verify=self.verify_cert,
                 )
             elif self.method == "POST":
                 response = requests.post(
                     url,
                     headers=base_headers,
-                    verify=True,
+                    verify=self.verify_cert,
                     json={},
                 )
             else:

metric.py

@@ -13,7 +13,6 @@ from .collections import __file__ as _
 from .collections_operators import __file__ as _
 from .dataclass import __file__ as _
 from .dataset_utils import __file__ as _
-from .db_utils import __file__ as _
 from .deprecation_utils import __file__ as _
 from .dialog_operators import __file__ as _
 from .dict_utils import __file__ as _
@@ -55,6 +54,7 @@ from .settings_utils import get_constants
 from .span_lableing_operators import __file__ as _
 from .split_utils import __file__ as _
 from .splitters import __file__ as _
+from .sql_utils import __file__ as _
 from .standard import __file__ as _
 from .stream import __file__ as _
 from .stream_operators import __file__ as _

metrics.py

@@ -1,4 +1,3 @@
-FINQA_HASH = "42430b8613082bb4b85d49210284135d"
 import ast
 import json
 import math
@@ -10,14 +9,27 @@ import warnings
 from abc import ABC, abstractmethod
 from collections import Counter, defaultdict
 from dataclasses import field
+from enum import Enum
 from functools import lru_cache
-from typing import Any, Dict, Generator, List, Literal, Optional, Tuple, Union
+from typing import (
+    Any,
+    Dict,
+    Generator,
+    Generic,
+    List,
+    Literal,
+    Optional,
+    Tuple,
+    TypeVar,
+    Union,
+)
 
 import evaluate
 import numpy
 import numpy as np
 import pandas as pd
 import requests
+from datasets import DownloadConfig
 from scipy.stats import bootstrap
 from scipy.stats._warnings_errors import DegenerateDataWarning
 
@@ -29,12 +41,12 @@ from .dataclass import (
     NonPositionalField,
     OptionalField,
 )
-from .db_utils import get_db_connector
 from .deprecation_utils import deprecation
-from .error_utils import Documentation, UnitxtWarning
+from .error_utils import Documentation, UnitxtError, UnitxtWarning
 from .inference import (
     HFPipelineBasedInferenceEngine,
     InferenceEngine,
+    LogProbInferenceEngine,
     TorchDeviceMixin,
     WMLInferenceEngineGeneration,
 )
@@ -51,15 +63,33 @@ from .operator import (
 from .operators import ArtifactFetcherMixin, Copy, Set
 from .random_utils import get_seed
 from .settings_utils import get_settings
+from .sql_utils import get_db_connector
 from .stream import MultiStream, Stream
 from .type_utils import Type, isoftype, parse_type_string, to_type_string
 from .utils import deep_copy, recursive_copy
 
+FINQA_HASH = "42430b8613082bb4b85d49210284135d"
+
 logger = get_logger()
 settings = get_settings()
 
 warnings.filterwarnings("ignore", category=DegenerateDataWarning)
 
+def hf_evaluate_load(path: str, *args, **kwargs):
+    if settings.hf_offline_metrics_path is not None:
+        path = os.path.join(settings.hf_offline_metrics_path, path)
+    return evaluate.load(
+        path,
+        *args,
+        **kwargs,
+        experiment_id=str(uuid.uuid4()),
+         download_config=DownloadConfig(
+                max_retries=settings.loaders_max_retries,
+            ),
+            verification_mode="no_checks",
+            trust_remote_code=settings.allow_unverified_code,
+            download_mode= "force_redownload" if settings.disable_hf_datasets_cache else "reuse_dataset_if_exists"
+        )
 
 class MetricsList(ListCollection):
     def verify(self):
@@ -378,8 +408,6 @@ class ConfidenceIntervalMixin(Artifact):
         return result
 
 
-from typing import Generic, TypeVar
-
 IntermediateType = TypeVar("IntermediateType")
 PredictionType = TypeVar("PredictionType")
 
@@ -1779,7 +1807,7 @@ class ExactMatchMM(InstanceMetric):
     @staticmethod
     @lru_cache(maxsize=10000)
     def exact_match(pred, gt):
-        """Brought from MMStar"""
+        """Brought from MMStar."""
         answer = gt.lower().strip().replace("\n", " ")
         predict = pred.lower().strip().replace("\n", " ")
         try:
@@ -1894,12 +1922,11 @@ class RelaxedCorrectness(GlobalMetric):
                 return_dict["relaxed_human_split"].append(score)
             else:
                 return_dict["relaxed_augmented_split"].append(score)
-        return_dict = {
+        return {
             key: sum(value) / len(value)
             for key, value in return_dict.items()
             if len(value) > 0
         }
-        return return_dict
 
     @staticmethod
     def _to_float(text: str):
@@ -2010,15 +2037,12 @@ class WebsrcSquadF1(GlobalMetric):
             string = string.lower()
 
             # strip leading and trailing whitespaces
-            string = string.strip()
-
-            return string
+            return string.strip()
 
         def _tokenize(text):
             # Regex pattern to match words and isolate punctuation
             pattern = r"\w+|[^\w\s]"
-            tokens = re.findall(pattern, text)
-            return tokens
+            return re.findall(pattern, text)
 
         def _compute_f1(sa, sb):
             sa = _normalize_str(sa)
@@ -2036,8 +2060,7 @@ class WebsrcSquadF1(GlobalMetric):
             comm = sa.intersection(sb)
             prec = len(comm) / len(sb)
             rec = len(comm) / len(sa)
-            f1 = 2 * prec * rec / (prec + rec) if prec + rec > 0 else 0
-            return f1
+            return 2 * prec * rec / (prec + rec) if prec + rec > 0 else 0
 
         judge_list = []
         for sample in samples:
@@ -2302,9 +2325,7 @@ class HuggingfaceMetric(GlobalMetric):
     def prepare(self):
         super().prepare()
 
-        self.metric = evaluate.load(
-            self.hf_metric_name, experiment_id=str(uuid.uuid4())
-        )
+        self.metric = hf_evaluate_load(self.hf_metric_name)
 
     def compute(
         self,
@@ -2379,9 +2400,7 @@ class HuggingfaceBulkMetric(BulkInstanceMetric):
     def prepare(self):
         super().prepare()
 
-        self.metric = evaluate.load(
-            self.hf_metric_name, experiment_id=str(uuid.uuid4())
-        )
+        self.metric = hf_evaluate_load(self.hf_metric_name)
 
     def compute(
         self,
@@ -2426,9 +2445,7 @@ class HuggingfaceInstanceMetric(InstanceMetric):
     def prepare(self):
         super().prepare()
 
-        self.metric = evaluate.load(
-            self.hf_metric_name, experiment_id=str(uuid.uuid4())
-        )
+        self.metric = hf_evaluate_load(self.hf_metric_name)
 
     def compute(self, references: List[Any], prediction: Any, task_data: Dict) -> dict:
         # invokes  module.compute, which invokes, e.g., meteor's _compute
@@ -2463,6 +2480,8 @@ class MeteorFast(ReductionInstanceMetric[str, Dict[str, float]]):
 
         nltk.download("wordnet", quiet=True)
         nltk.download("omw-1.4", quiet=True)
+        nltk.download("punkt", quiet=True)
+        nltk.download("punkt_tab", quiet=True)
         from nltk import word_tokenize
         from nltk.translate import meteor_score
 
@@ -2530,7 +2549,7 @@ class F1(GlobalMetric):
     def prepare(self):
         super().prepare()
 
-        self._metric = evaluate.load(self.metric, experiment_id=str(uuid.uuid4()))
+        self._metric = hf_evaluate_load(self.metric)
 
     def get_str_id(self, str):
         if str not in self.str_to_id:
@@ -2807,8 +2826,8 @@ class F1MultiLabel(GlobalMetric, PackageRequirementsMixin):
     def prepare(self):
         super().prepare()
 
-        self._metric = evaluate.load(
-            self.metric, "multilabel", experiment_id=str(uuid.uuid4())
+        self._metric = hf_evaluate_load(
+            self.metric, "multilabel"
         )
 
     def add_str_to_id(self, str):
@@ -3443,13 +3462,16 @@ class BertScore(MapReduceMetric[str, Dict[str, float]], TorchDeviceMixin):
 
     def prepare(self):
         super().prepare()
-        from evaluate import load
-
-        self.bertscore = load("bertscore", experiment_id=str(uuid.uuid4()))
+        self.bertscore = None
 
     def map_stream(
         self, evaluation_inputs_stream: Generator[EvaluationInput[str], None, None]
     ):
+        from evaluate import load
+
+        if self.bertscore is None:
+            self.bertscore = load("bertscore", experiment_id=str(uuid.uuid4()))
+
         predictions = []
         references = []
         for prediction, reference, _ in evaluation_inputs_stream:
@@ -3495,17 +3517,17 @@ class SentenceBert(MapReduceMetric[str, float], TorchDeviceMixin):
 
     def prepare(self):
         super().prepare()
-        from sentence_transformers import SentenceTransformer
-
-        self.model = SentenceTransformer(self.model_name, device=self.get_device_id())
+        self.model = None
 
     def map_stream(
         self, evaluation_inputs_stream: Generator[EvaluationInput, None, None]
     ):
-        # if settings.mock_inference_mode:
-        #     return [0.5 for _ in evaluation_inputs_stream]
+        from sentence_transformers import SentenceTransformer, util
 
-        from sentence_transformers import util
+        if self.model is None:
+            self.model = SentenceTransformer(
+                self.model_name, device=self.get_device_id()
+            )
 
         scores = []
 
@@ -3553,15 +3575,23 @@ class Reward(MapReduceMetric[str, float], TorchDeviceMixin):
 
     def prepare(self):
         super().prepare()
-        from transformers import pipeline
-
-        self.model = pipeline(
-            "text-classification", model=self.model_name, device=self.get_device()
-        )
+        self.model = None
 
     def map_stream(
         self, evaluation_inputs_stream: Generator[EvaluationInput[str], None, None]
     ):
+        if settings.mock_inference_mode:
+            return [0.5 for _ in evaluation_inputs_stream]
+
+        from transformers import pipeline
+
+        if self.model is None:
+            self.model = pipeline(
+                "text-classification",
+                model=self.model_name,
+                device=self.get_device(),
+            )
+
         inputs = []
         for prediction, references, _ in evaluation_inputs_stream:
             inputs.append({"text": references[0], "text_pair": prediction})
@@ -3591,8 +3621,11 @@ class Detector(BulkInstanceMetric):
         from transformers import pipeline
 
         device = "cuda:0" if torch.cuda.is_available() else "cpu"
+        model_path = self.model_name
+        if settings.hf_offline_models_path is not None:
+            model_path = os.path.join(settings.hf_offline_models_path, model_path)
         self.pipe = pipeline(
-            "text-classification", model=self.model_name, device=device
+            "text-classification", model=model_path, device=device,
         )
 
     def compute(
@@ -3624,10 +3657,14 @@ class RegardMetric(GlobalMetric):
         super().prepare()
         from transformers import AutoModelForSequenceClassification, AutoTokenizer
 
+        model_path = self.model_name
+        if settings.hf_offline_models_path is not None:
+            model_path = os.path.join(settings.hf_offline_models_path, model_path)
         self.regard_model = AutoModelForSequenceClassification.from_pretrained(
-            self.model_name
+            model_path,
+
         )
-        self.regard_tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.regard_tokenizer = AutoTokenizer.from_pretrained(model_path)
 
     def _evaluate(self, predictions, inputs):
         import torch
@@ -3810,10 +3847,14 @@ class SafetyMetric(MapReduceMetric[str, Tuple[float, str]], TorchDeviceMixin):
         super().prepare()
         from transformers import pipeline
 
+        model_path = self.reward_name
+        if settings.hf_offline_models_path is not None:
+            model_path = os.path.join(settings.hf_offline_models_path, model_path)
+
         if not settings.mock_inference_mode:
             self.model = pipeline(
                 "text-classification",
-                model=self.reward_name,
+                model=model_path,
                 device=self.get_device(),
             )
 
@@ -3997,7 +4038,11 @@ class Perplexity(BulkInstanceMetric):
         if self.lm is None:
             from transformers import AutoConfig
 
-            config = AutoConfig.from_pretrained(self.model_name, trust_remote_code=True)
+            model_path = self.model_name
+            if settings.hf_offline_models_path is not None:
+                model_path = os.path.join(settings.hf_offline_models_path, model_path)
+
+            config = AutoConfig.from_pretrained(model_path, trust_remote_code=True)
             self.lm = (
                 self.EncoderDecoderLM(
                     model_name=self.model_name, single_token_mode=self.single_token_mode
@@ -4075,10 +4120,13 @@ class Perplexity(BulkInstanceMetric):
 
             self.model_name = model_name
             self.device = "cuda:0" if torch.cuda.is_available() else "cpu"
+            model_path = self.model_name
+            if settings.hf_offline_models_path is not None:
+                model_path = os.path.join(settings.hf_offline_models_path, model_path)
             self.model = (
-                self.model_class().from_pretrained(self.model_name).to(self.device)
+                self.model_class().from_pretrained(model_path).to(self.device)
             )
-            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.tokenizer = AutoTokenizer.from_pretrained(model_path)
             if self.tokenizer.pad_token_id is None:
                 self.tokenizer.pad_token_id = self.tokenizer.eos_token_id
             self.single_token_mode = single_token_mode
@@ -4243,7 +4291,7 @@ class FaithfulnessHHEM(BulkInstanceMetric):
     batch_size: int = 2
     model_name: str = "vectara/hallucination_evaluation_model"
     prediction_type = str
-    single_reference_per_prediction = True
+   # single_reference_per_prediction = True
     max_context_words = 4096
     reduction_map = {"mean": [main_score]}
 
@@ -4260,9 +4308,11 @@ class FaithfulnessHHEM(BulkInstanceMetric):
         else:
             device = "cpu"
         from transformers import AutoModelForSequenceClassification
-
+        model_path = self.model_name
+        if settings.hf_offline_models_path is not None:
+            model_path = os.path.join(settings.hf_offline_models_path, model_path)
         self.model = AutoModelForSequenceClassification.from_pretrained(
-            self.model_name, trust_remote_code=True
+            model_path, trust_remote_code=True
         ).to(device)
 
     def compute(
@@ -4275,7 +4325,8 @@ class FaithfulnessHHEM(BulkInstanceMetric):
 
         # treat the references as the contexts and the predictions as answers
         # concat references
-        contexts = ["\n".join(refs) for refs in references]
+
+        contexts = ["\n".join([str(r) for r in refs]) for refs in references]
         contexts = [" ".join(c.split(" ")[: self.max_context_words]) for c in contexts]
         answers = predictions
 
@@ -5620,9 +5671,9 @@ class MetricsEnsemble(InstanceMetric, ArtifactFetcherMixin):
 
     def create_ensemble_scores(self, instance):
         score = self.ensemble(instance)
-        instance[
-            "prediction"
-        ] = score  # We use here the prediction field to pass the score to the compute method.
+        instance["prediction"] = (
+            score  # We use here the prediction field to pass the score to the compute method.
+        )
         return instance
 
     def ensemble(self, instance):
@@ -5835,77 +5886,153 @@ class PredictionLength(InstanceMetric):
         return {self.main_score: [len(prediction)], "score_name": self.main_score}
 
 
-class GraniteGuardianWMLMetric(InstanceMetric):
+class RiskType(str, Enum):
+    """Risk type for the Granite Guardian models."""
+
+    RAG = "rag_risk"
+    USER_MESSAGE = "user_risk"
+    ASSISTANT_MESSAGE = "assistant_risk"
+    AGENTIC = "agentic_risk"
+    CUSTOM_RISK = "custom_risk"
+
+
+class GraniteGuardianBase(InstanceMetric):
     """Return metric for different kinds of "risk" from the Granite-3.0 Guardian model."""
 
-    main_score = "granite_guardian"
     reduction_map: Dict[str, List[str]] = None
     prediction_type = float
+    main_score = None
+    reduction_map = {}
+    wml_model_name: str = "ibm/granite-guardian-3-8b"
+    hf_model_name: str = "ibm-granite/granite-guardian-3.1-8b"
+
+    wml_params = {
+        "decoding_method": "greedy",
+        "max_new_tokens": 20,
+        "temperature": 0,
+        "return_options": {
+            "top_n_tokens": 5,
+            "input_text": True,
+            "input_tokens": False,
+        },
+    }
 
-    model_name: str = "ibm/granite-guardian-3-8b"
-    hf_model_name: str = "ibm-granite/granite-guardian-3.0-8b"
     safe_token = "No"
     unsafe_token = "Yes"
 
-    inference_engine: WMLInferenceEngineGeneration = None
+    inference_engine: LogProbInferenceEngine = None
     generation_params: Dict = None
     risk_name: str = None
+    risk_type: RiskType = None
+    risk_definition: Optional[str] = None
+
+    user_message_field: str = "user"
+    assistant_message_field: str = "assistant"
+    context_field: str = "context"
+    tools_field: str = "tools"
+
+    available_risks: Dict[RiskType, List[str]] = {
+        RiskType.USER_MESSAGE: [
+            "harm",
+            "social_bias",
+            "jailbreak",
+            "violence",
+            "profanity",
+            "unethical_behavior",
+        ],
+        RiskType.ASSISTANT_MESSAGE: [
+            "harm",
+            "social_bias",
+            "violence",
+            "profanity",
+            "unethical_behavior",
+        ],
+        RiskType.RAG: ["context_relevance", "groundedness", "answer_relevance"],
+        RiskType.AGENTIC: ["function_call"],
+    }
 
-    _requirements_list: List[str] = ["ibm_watsonx_ai", "torch", "transformers"]
+    _requirements_list: List[str] = ["torch", "transformers"]
 
     def prepare(self):
-        self.reduction_map = {"mean": [self.main_score]}
-
-    def compute(self, references: List[Any], prediction: Any, task_data: Dict) -> dict:
         from transformers import AutoTokenizer
-
+        if not isinstance(self.risk_type, RiskType):
+            self.risk_type = RiskType[self.risk_type]
         if not hasattr(self, "_tokenizer") or self._tokenizer is None:
+            model_path = self.hf_model_name
+            if settings.hf_offline_models_path is not None:
+                model_path = os.path.join(settings.hf_offline_models_path, model_path)
             self._tokenizer = AutoTokenizer.from_pretrained(self.hf_model_name)
-            self.inference_engine = WMLInferenceEngineGeneration(
-                model_name=self.model_name,
-            )
-            self.inference_engine._load_model()
-            self.model = self.inference_engine._model
-            self.generation_params = self.inference_engine._set_logprobs_params({})
 
-        messages = self.process_input_fields(task_data)
+    def verify(self):
+        super().verify()
+        assert (
+            self.risk_type == RiskType.CUSTOM_RISK
+            or self.risk_name in self.available_risks[self.risk_type]
+        ), UnitxtError(
+            f"The risk '{self.risk_name}' is not a valid '{' '.join([word[0].upper() + word[1:] for word in self.risk_type.split('_')])}'"
+        )
+
+    @abstractmethod
+    def verify_granite_guardian_config(self, task_data):
+        pass
+
+    @abstractmethod
+    def process_input_fields(self, task_data):
+        pass
+
+    @classmethod
+    def get_available_risk_names(cls):
+        return cls.available_risks[cls.risk_type]
+
+    def set_main_score(self):
+        self.main_score = self.risk_name
+        self.reduction_map = {"mean": [self.main_score]}
+
+    def get_prompt(self, messages):
         guardian_config = {"risk_name": self.risk_name}
-        processed_input = self._tokenizer.apply_chat_template(
+        if self.risk_type == RiskType.CUSTOM_RISK:
+            guardian_config["risk_definition"] = self.risk_definition
+
+        return self._tokenizer.apply_chat_template(
             messages,
             guardian_config=guardian_config,
             tokenize=False,
             add_generation_prompt=True,
         )
 
-        result = self.model.generate(
-            prompt=[processed_input],
-            params=self.generation_params,
+    def compute(self, references: List[Any], prediction: Any, task_data: Dict) -> dict:
+        self.verify_granite_guardian_config(task_data)
+        self.set_main_score()
+
+        if self.inference_engine is None:
+            self.inference_engine = WMLInferenceEngineGeneration(
+                model_name=self.wml_model_name,
+                **self.wml_params,
+            )
+        logger.debug(
+            f'Risk type is "{self.risk_type}" and risk name is "{self.risk_name}"'
         )
-        generated_tokens_list = result[0]["results"][0]["generated_tokens"]
+        messages = self.process_input_fields(task_data)
+        prompt = self.get_prompt(messages)
+        result = self.inference_engine.infer_log_probs([{"source": prompt}])
+        generated_tokens_list = result[0]
         label, prob_of_risk = self.parse_output(generated_tokens_list)
-        score = 1 - prob_of_risk if label is not None else np.nan
-        return {self.main_score: score}
-
-    def process_input_fields(self, task_data):
-        if self.risk_name == "groundedness":
-            messages = [
-                {"role": "context", "content": "\n".join(task_data["contexts"])},
-                {"role": "assistant", "content": task_data["answer"]},
-            ]
-        elif self.risk_name == "answer_relevance":
-            messages = [
-                {"role": "user", "content": task_data["question"]},
-                {"role": "assistant", "content": task_data["answer"]},
-            ]
-        elif self.risk_name == "context_relevance":
-            messages = [
-                {"role": "user", "content": task_data["question"]},
-                {"role": "context", "content": "\n".join(task_data["contexts"])},
-            ]
-        else:
-            raise NotImplementedError()
+        confidence_score = (
+            (prob_of_risk if prob_of_risk > 0.5 else 1 - prob_of_risk)
+            if label is not None
+            else np.nan
+        )
+        result = {
+            self.main_score: prob_of_risk,
+            f"{self.main_score}_prob_of_risk": prob_of_risk,
+            f"{self.main_score}_certainty": confidence_score,
+            f"{self.main_score}_label": label,
+        }
+        logger.debug(f"Results are ready:\n{result}")
+        return result
 
-        return messages
+    def create_message(self, role: str, content: str) -> List[Dict[str, str]]:
+        return [{"role": role, "content": content}]
 
     def parse_output(self, generated_tokens_list):
         top_tokens_list = [
@@ -5944,10 +6071,179 @@ class GraniteGuardianWMLMetric(InstanceMetric):
         ).numpy()
 
 
-class ExecutionAccuracy(InstanceMetric):
-    reduction_map = {"mean": ["execution_accuracy"]}
-    main_score = "execution_accuracy"
-    ci_scores = ["execution_accuracy"]
+class GraniteGuardianUserRisk(GraniteGuardianBase):
+    risk_type = RiskType.USER_MESSAGE
+
+    def verify_granite_guardian_config(self, task_data):
+        # User message risks only require the user message field and are the same as the assistant message risks, except for jailbreak
+        assert self.user_message_field in task_data, UnitxtError(
+            f'Task data must contain "{self.user_message_field}" field'
+        )
+
+    def process_input_fields(self, task_data):
+        messages = []
+        messages += self.create_message("user", task_data[self.user_message_field])
+        return messages
+
+
+class GraniteGuardianAssistantRisk(GraniteGuardianBase):
+    risk_type = RiskType.ASSISTANT_MESSAGE
+
+    def verify_granite_guardian_config(self, task_data):
+        assert (
+            self.assistant_message_field in task_data
+            and self.user_message_field in task_data
+        ), UnitxtError(
+            f'Task data must contain "{self.assistant_message_field}" and "{self.user_message_field}" fields'
+        )
+
+    def process_input_fields(self, task_data):
+        messages = []
+        messages += self.create_message("user", task_data[self.user_message_field])
+        messages += self.create_message(
+            "assistant", task_data[self.assistant_message_field]
+        )
+        return messages
+
+
+class GraniteGuardianRagRisk(GraniteGuardianBase):
+    risk_type = RiskType.RAG
+
+    def verify_granite_guardian_config(self, task_data):
+        if self.risk_name == "context_relevance":
+            assert (
+                self.context_field in task_data and self.user_message_field in task_data
+            ), UnitxtError(
+                f'Task data must contain "{self.context_field}" and "{self.user_message_field}" fields'
+            )
+        elif self.risk_name == "groundedness":
+            assert (
+                self.context_field in task_data
+                and self.assistant_message_field in task_data
+            ), UnitxtError(
+                f'Task data must contain "{self.context_field}" and "{self.assistant_message_field}" fields'
+            )
+        elif self.risk_name == "answer_relevance":
+            assert (
+                self.user_message_field in task_data
+                and self.assistant_message_field in task_data
+            ), UnitxtError(
+                f'Task data must contain "{self.user_message_field}" and "{self.assistant_message_field}" fields'
+            )
+
+    def process_input_fields(self, task_data):
+        messages = []
+        if self.risk_name == "context_relevance":
+            messages += self.create_message("user", task_data[self.user_message_field])
+            messages += self.create_message("context", task_data[self.context_field])
+        elif self.risk_name == "groundedness":
+            messages += self.create_message("context", task_data[self.context_field])
+            messages += self.create_message(
+                "assistant", task_data[self.assistant_message_field]
+            )
+        elif self.risk_name == "answer_relevance":
+            messages += self.create_message("user", task_data[self.user_message_field])
+            messages += self.create_message(
+                "assistant", task_data[self.assistant_message_field]
+            )
+        return messages
+
+
+class GraniteGuardianAgenticRisk(GraniteGuardianBase):
+    risk_type = RiskType.AGENTIC
+
+    def verify_granite_guardian_config(self, task_data):
+        assert (
+            self.tools_field in task_data
+            and self.user_message_field in task_data
+            and self.assistant_message_field in task_data
+        ), UnitxtError(
+            f'Task data must contain "{self.tools_field}", "{self.assistant_message_field}" and "{self.user_message_field}" fields'
+        )
+
+    def process_input_fields(self, task_data):
+        messages = []
+        messages += self.create_message(
+            "tools", json.loads(task_data[self.tools_field])
+        )
+        messages += self.create_message("user", task_data[self.user_message_field])
+        messages += self.create_message(
+            "assistant", task_data[self.assistant_message_field]
+        )
+        return messages
+
+
+class GraniteGuardianCustomRisk(GraniteGuardianBase):
+    risk_type = RiskType.CUSTOM_RISK
+
+    def verify(self):
+        super().verify()
+        assert self.risk_type is not None, UnitxtError(
+            "In a custom risk, risk_type must be defined"
+        )
+
+    def verify_granite_guardian_config(self, task_data):
+        # even though this is a custom risks, we will limit the
+        # message roles to be a subset of the roles Granite Guardian
+        # was trained with: user, assistant, context & tools.
+        # we just checked whether at least one of them is provided
+        assert (
+            self.tools_field in task_data
+            or self.user_message_field in task_data
+            or self.assistant_message_field in task_data
+            or self.context_field in task_data
+        ), UnitxtError(
+            f'Task data must contain at least one of"{self.tools_field}", "{self.assistant_message_field}", "{self.user_message_field}" or "{self.context_field}" fields'
+        )
+
+    def process_input_fields(self, task_data):
+        messages = []
+        if self.context_field in task_data:
+            messages += self.create_message("context", task_data[self.context_field])
+        if self.tools_field in task_data:
+            messages += self.create_message(
+                "tools", json.loads(task_data[self.tools_field])
+            )
+        if self.user_message_field in task_data:
+            messages += self.create_message("user", task_data[self.user_message_field])
+        if self.assistant_message_field in task_data:
+            messages += self.create_message(
+                "assistant", task_data[self.assistant_message_field]
+            )
+        return messages
+
+
+RISK_TYPE_TO_CLASS: Dict[RiskType, GraniteGuardianBase] = {
+    RiskType.USER_MESSAGE: GraniteGuardianUserRisk,
+    RiskType.ASSISTANT_MESSAGE: GraniteGuardianAssistantRisk,
+    RiskType.RAG: GraniteGuardianRagRisk,
+    RiskType.AGENTIC: GraniteGuardianAgenticRisk,
+    RiskType.CUSTOM_RISK: GraniteGuardianCustomRisk,
+}
+
+
+class SQLExecutionAccuracy(InstanceMetric):
+    reduction_map = {
+        "mean": [
+            "execution_accuracy",
+            "non_empty_execution_accuracy",
+            "subset_non_empty_execution_result",
+            "non_empty_gold_df",
+            "gold_sql_runtime",
+            "predicted_sql_runtime",
+            "pred_to_gold_runtime_ratio",
+            "gold_error",
+            "predicted_error",
+        ]
+    }
+    main_score = "non_empty_execution_accuracy"
+    ci_scores = [
+        "execution_accuracy",
+        "non_empty_execution_accuracy",
+        "subset_non_empty_execution_result",
+        "gold_sql_runtime",
+        "predicted_sql_runtime",
+    ]
 
     prediction_type = "Any"  # string representation is compared
     sql_timeout = 100.0
@@ -5955,73 +6251,229 @@ class ExecutionAccuracy(InstanceMetric):
     _requirements_list = ["sqlglot", "func_timeout"]
 
     @staticmethod
-    def equivalent_sqls(expected: str, generated: str) -> int:
-        from sqlglot import diff, parse_one
-        from sqlglot.optimizer import optimize
+    def compare_dfs_ignore_colnames(df1, df2):
+        """Compares two DataFrames based on row content, ignoring column names.
 
-        t_diff = diff(
-            optimize(parse_one(expected.lower()).sql(pretty=True)),
-            optimize(parse_one(generated.lower()).sql(pretty=True)),
-        )
-        sql_diff = sum(0 if (e.__class__.__name__ == "Keep") else 1 for e in t_diff)
+        Args:
+            df1 (pd.DataFrame): Pandas DataFrame 1 to compare.
+            df2 (pd.DataFrame): Pandas DataFrame 2 to compare.
 
-        return 1 if sql_diff == 0 else 0
+        Returns:
+            True if the DataFrames have the same content (ignoring column names),
+            False otherwise.
+        """
+        df1.fillna(0, inplace=True)
+        df2.fillna(0, inplace=True)
 
-    def run_sql_and_match(self, predicted_sql: str, gold_sql: str, connector) -> int:
-        """Runs SQL queries using the provided connector and checks if the results match."""
-        if predicted_sql.lower().strip() == gold_sql.lower().strip():
-            return 1  # if the SQLs are exactly the same, return 1
+        if df1.shape != df2.shape:
+            return False
+
+        # run over all columns of d11,
+        # and see if there is a columns in df2 that matches it,
+        # if not return False, if all the columns worked return tue
+        for df1_col in df1.columns:
+            col_matched = False
+            for df2_col in df2.columns:
+                if all(df1[df1_col].values == df2[df2_col].values):
+                    col_matched = True
+            if not col_matched:
+                return False
+
+        return True
+
+    @staticmethod
+    def is_subset_ignore_colnames(df1, df2):
+        """Checks if df1 is a subset of df2 based on row content, ignoring column names.
+
+        Args:
+            df1: Pandas DataFrame 1 to compare.
+            df2: Pandas DataFrame 2 to compare.
+
+        Returns:
+            True if df1 is a subset of df2 based on column values,
+            False otherwise.
+        """
+        if df1.empty or df2.empty or df1.shape[1] > df2.shape[1]:
+            return False
+
+        def make_hashable(value):
+            if isinstance(value, dict):
+                return json.dumps(value, sort_keys=True)
+            if isinstance(value, list):
+                return tuple(value)
+            return value
+
+        df1_cols = [
+            tuple(make_hashable(value) for value in df1.iloc[:, i])
+            for i in range(df1.shape[1])
+        ]
+        df2_cols = [
+            tuple(make_hashable(value) for value in df2.iloc[:, j])
+            for j in range(df2.shape[1])
+        ]
+        df2_cols_count = Counter(df2_cols)
+        for col in df1_cols:
+            if df2_cols_count[col] > 0:
+                df2_cols_count[col] -= 1
+            else:
+                return False
+
+        return True
+
+    def get_sql_execution_results(
+        self, predicted_sql: str, gold_sql: str, connector
+    ) -> (int, int, int, int, int, int, int, int, int, str, str, str):
+        """Runs SQL queries using the provided connector and gets scores and results.
+
+        Args:
+            predicted_sql (str): predicted SQL query
+            gold_sql (str): gold reference SQL query
+            connector: database connector
 
+        Returns:
+        a 12-tuple of
+        1. execution_result: if df responses match
+        2. non_empty_execution_result: if dfs are non-empty and match
+        3. subset_non_empty_execution_result: if non-empty dfs and gt df subset of predicted df
+        4. non_empty_gold_df: if gt df is non-empty
+        5. gold_sql_runtime: ground truth query runtime
+        6. predicted_sql_runtime: predicted query runtime
+        7. pred_to_gold_runtime_ratio: ratio of predicted query runtime to gt query runtime
+        8. gold_error: if gt has an error
+        9. predicted_error: if predicted query has an error
+        10. ground truth dataframe
+        11. predicted query's dataframe
+        12. error message (if any)
+        """
+        import time
+
+        from func_timeout import func_timeout
+
+        from .sql_utils import sqlglot_optimized_equivalence
+
+        gold_res = None
+        gold_error = ""
+        gold_sql_runtime = 0
         try:
-            if self.equivalent_sqls(gold_sql, predicted_sql):
-                return 1
+            start_time = time.perf_counter()
+            gold_res, gold_error = func_timeout(
+                self.sql_timeout,
+                connector.execute_query,
+                args=(gold_sql,),
+            )
+            end_time = time.perf_counter()
+            gold_sql_runtime = end_time - start_time
+        except Exception as e:
+            gold_error = f"Error executing gold SQL: {e}"
+        if gold_error is not None:
+            return (
+                0,
+                0,
+                0,
+                0,
+                gold_sql_runtime,
+                0,
+                0,
+                0,
+                0,
+                "",
+                "",
+                gold_error,
+            )
+
+        gold_df = pd.DataFrame(gold_res)
+        non_empty_gold_df = 0 if gold_df.empty else 1
+
+        no_execution_match_result = (
+            1,
+            non_empty_gold_df,
+            non_empty_gold_df,
+            non_empty_gold_df,
+            gold_sql_runtime,
+            0,
+            0,
+            1,
+            0,
+            gold_df.to_json(),
+            gold_df.to_json(),
+            "",
+        )
+        if predicted_sql.lower().strip() == gold_sql.lower().strip():
+            return no_execution_match_result
+        try:
+            if sqlglot_optimized_equivalence(gold_sql, predicted_sql):
+                return no_execution_match_result
         except Exception as e:  # Catch specific exceptions if possible
             logger.info(
-                f"Error in equivalent_sqls: {e}. Treating as non-equivalent and going to test with the db."
+                f"Couldn't test equivalent_sqls: {e}. Treating as non-equivalent and going to test with the db."
             )
 
+        pred_res = None
+        pred_error = ""
+        pred_sql_runtime = 0
         try:
-            gold_res = connector.execute_query(gold_sql)
+            start_time = time.perf_counter()
+            pred_res, pred_error = func_timeout(
+                self.sql_timeout,
+                connector.execute_query,
+                args=(predicted_sql,),
+            )
+            end_time = time.perf_counter()
+            pred_sql_runtime = end_time - start_time
         except Exception as e:
-            raise OSError(
-                "Error executing gold SQL, if gold does not execute metric should fail"
-            ) from e
+            pred_error = f"Error executing predicted SQL: {e}"
+            logger.info(pred_error)
 
-        try:
-            pred_res = connector.execute_query(predicted_sql)
-        except Exception as e:
-            logger.info(f"Error executing predicted SQL: {e}")
-            return 0  # if the predicted SQL fails to execute, result is 0
+        pred_to_gold_runtime_ratio = (
+            float(pred_sql_runtime) / gold_sql_runtime if gold_sql_runtime > 0 else 0
+        )
 
         if pred_res is None:
-            if gold_res is None:
-                return 1
-            return 0
-
-        # if pred_res is dict with results take this as the result
-        if isinstance(pred_res, dict):
-            pred_res = pred_res["results"]
-            gold_res = gold_res["results"]
+            return (
+                0,
+                0,
+                0,
+                0,
+                gold_sql_runtime,
+                pred_sql_runtime,
+                pred_to_gold_runtime_ratio,
+                0,
+                1,
+                "",
+                "",
+                pred_error,
+            )
 
-        def normalize_tuple(tup):
-            """Normalizes a tuple by sorting its non-None elements.
+        predicted_df = pd.DataFrame(pred_res)
 
-            Args:
-                tup: The input tuple.
+        execution_result = (
+            1 if self.compare_dfs_ignore_colnames(predicted_df, gold_df) else 0
+        )
 
-            Returns:
-                A tuple with non-None elements sorted first, followed by None values.
-            """
-            return sorted([str(item) for item in tup])
+        subset_non_empty_execution_result = 0
+        non_empty_execution_result = 0
+        if non_empty_gold_df:
+            if execution_result == 1:
+                non_empty_execution_result = 1
+            if self.is_subset_ignore_colnames(gold_df, predicted_df):
+                subset_non_empty_execution_result = 1
 
-        return int(
-            sorted([normalize_tuple(t) for t in pred_res])
-            == sorted([normalize_tuple(t) for t in gold_res])
+        return (
+            execution_result,
+            non_empty_execution_result,
+            subset_non_empty_execution_result,
+            non_empty_gold_df,
+            gold_sql_runtime,
+            pred_sql_runtime,
+            pred_to_gold_runtime_ratio,
+            0,
+            0,
+            gold_df.to_json(),
+            predicted_df.to_json(),
+            pred_error,
         )
 
     def compute(self, references: List[Any], prediction: str, task_data: Dict) -> dict:
-        from func_timeout import FunctionTimedOut, func_timeout
-
         predicted_sql = prediction
         execution_result: float = 0.0
 
@@ -6033,18 +6485,115 @@ class ExecutionAccuracy(InstanceMetric):
 
             db_connector = get_db_connector(task_data["db"]["db_type"])(task_data["db"])
 
-            try:
-                execution_result = func_timeout(
-                    self.sql_timeout,
-                    self.run_sql_and_match,
-                    args=(predicted_sql, references[0], db_connector),
-                )  # type: ignore
-            except FunctionTimedOut:
-                logger.error("QUERY TIMEOUT, returning score=0 for this instance")
-                execution_result = 0.0
-
-        result = {self.main_score: float(execution_result)}
-        logger.debug(f"Result: {result}")
+            logger.debug(
+                f"Starting to get SQL execution results over DB: {task_data['db']}"
+            )
+            (
+                execution_result,
+                non_empty_execution_result,
+                subset_non_empty_execution_result,
+                non_empty_gold_df,
+                gold_sql_runtime,
+                predicted_sql_runtime,
+                pred_to_gold_runtime_ratio,
+                gold_error,
+                predicted_error,
+                gold_df_json,
+                predicted_df_json,
+                error_message,
+            ) = self.get_sql_execution_results(
+                predicted_sql, references[0], db_connector
+            )
+
+        result = {
+            "execution_accuracy": float(execution_result),
+            "non_empty_execution_accuracy": float(non_empty_execution_result),
+            "subset_non_empty_execution_result": float(
+                subset_non_empty_execution_result
+            ),
+            "non_empty_gold_df": float(non_empty_gold_df),
+            "gold_sql_runtime": float(gold_sql_runtime),
+            "predicted_sql_runtime": float(predicted_sql_runtime),
+            "pred_to_gold_runtime_ratio": float(pred_to_gold_runtime_ratio),
+            "gold_error": float(gold_error),
+            "predicted_error": float(predicted_error),
+            "error_message": str(error_message),
+            "gold_df_json": str(gold_df_json),
+            "predicted_df_json": str(predicted_df_json),
+        }
+        result["score"] = result[self.main_score]
+        result["score_name"] = self.main_score
+        logger.debug(f"SQL Execution Accuracy Result: {result}")
+        return result
+
+
+class SQLNonExecutionAccuracy(InstanceMetric):
+    reduction_map = {
+        "mean": [
+            "sqlglot_validity",
+            "sqlparse_validity",
+            "sqlglot_equivalence",
+            "sqlglot_optimized_equivalence",
+            "sqlparse_equivalence",
+            "sql_exact_match",
+        ]
+    }
+    main_score = "sqlglot_equivalence"
+    ci_scores = [
+        "sqlglot_validity",
+        "sqlparse_validity",
+        "sqlglot_equivalence",
+        "sqlglot_optimized_equivalence",
+        "sqlparse_equivalence",
+        "sql_exact_match",
+    ]
+
+    prediction_type = "Any"  # string representation is compared
+
+    _requirements_list = ["sqlglot", "sqlparse"]
+
+    def compute(self, references: List[Any], prediction: str, task_data: Dict) -> dict:
+        from .sql_utils import (
+            is_sqlglot_parsable,
+            is_sqlparse_parsable,
+            sql_exact_match,
+            sqlglot_optimized_equivalence,
+            sqlglot_parsed_queries_equivalent,
+            sqlparse_queries_equivalent,
+        )
+
+        predicted_sql = prediction
+        gold_sql = references[0]
+
+        if predicted_sql and predicted_sql.strip() != "":
+            if not predicted_sql.startswith("SELECT") and "SELECT" in predicted_sql:
+                predicted_sql = predicted_sql[predicted_sql.find("SELECT") :]
+            if ";" in predicted_sql:
+                predicted_sql = predicted_sql[: predicted_sql.find(";") + 1]
+
+        is_sqlglot_parsable = is_sqlglot_parsable(predicted_sql)
+        is_sqlparse_parsable = is_sqlparse_parsable(predicted_sql)
+        result = {
+            "sqlglot_validity": float(is_sqlglot_parsable),
+            "sqlparse_validity": float(is_sqlparse_parsable),
+            "sqlglot_equivalence": float(
+                sqlglot_parsed_queries_equivalent(predicted_sql, gold_sql)
+                if is_sqlglot_parsable
+                else 0
+            ),
+            "sqlglot_optimized_equivalence": float(
+                sqlglot_optimized_equivalence(predicted_sql, gold_sql)
+                if is_sqlglot_parsable
+                else 0
+            ),
+            "sqlparse_equivalence": float(
+                sqlparse_queries_equivalent(predicted_sql, gold_sql)
+                if is_sqlparse_parsable
+                else 0
+            ),
+            "sql_exact_match": float(sql_exact_match(predicted_sql, gold_sql)),
+        }
+        logger.debug(f"SQL Non Execution Accuracy Result: {result}")
         result["score"] = result[self.main_score]
         result["score_name"] = self.main_score
         return result

operator.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, Generator, List, Optional, Union
 from pkg_resources import DistributionNotFound, VersionConflict, require
 
 from .artifact import Artifact
-from .dataclass import InternalField, NonPositionalField
+from .dataclass import FinalField, InternalField, NonPositionalField
 from .settings_utils import get_constants
 from .stream import DynamicStream, EmptyStreamError, MultiStream, Stream
 
@@ -20,6 +20,7 @@ class PackageRequirementsMixin(Artifact):
     """Base class used to automatically check for the existence of required Python dependencies for an artifact (e.g., Operator or Metric).
 
     The _requirements_list is either a list of required packages or a dictionary mapping required packages to installation instructions.
+    The _requirements_list should be used at class level definition, and the requirements at instance creation.
 
     - **List format**: Just specify the package names, optionally with version annotations (e.g., ["torch>=1.2.4", "numpy<1.19"]).
     - **Dict format**: Specify package names as keys and installation instructions as values
@@ -32,9 +33,13 @@ class PackageRequirementsMixin(Artifact):
     _requirements_list: Union[List[str], Dict[str, str]] = InternalField(
         default_factory=list
     )
+    requirements: Union[List[str], Dict[str, str]] = FinalField(
+        also_positional=False, default_factory=list
+    )
 
     def prepare(self):
-        self.check_missing_requirements()
+        self.check_missing_requirements(self._requirements_list)
+        self.check_missing_requirements(self.requirements)
         super().prepare()
 
     def check_missing_requirements(self, requirements=None):

operators.py

@@ -1484,28 +1484,32 @@ class IntersectCorrespondingFields(InstanceOperator):
 
     Assume the instances contain a field of 'labels' and a field with the labels' corresponding 'positions' in the text.
 
-    IntersectCorrespondingFields(field="label",
-                                 allowed_values=["b", "f"],
-                                 corresponding_fields_to_intersect=["position"])
+    .. code-block:: text
+
+        IntersectCorrespondingFields(field="label",
+                                    allowed_values=["b", "f"],
+                                    corresponding_fields_to_intersect=["position"])
 
     would keep only "b" and "f" values in 'labels' field and
     their respective values in the 'position' field.
     (All other fields are not effected)
 
-    Given this input:
+    .. code-block:: text
 
-    [
-        {"label": ["a", "b"],"position": [0,1],"other" : "not"},
-        {"label": ["a", "c", "d"], "position": [0,1,2], "other" : "relevant"},
-        {"label": ["a", "b", "f"], "position": [0,1,2], "other" : "field"}
-    ]
+        Given this input:
 
-    So the output would be:
-    [
-            {"label": ["b"], "position":[1],"other" : "not"},
-            {"label": [], "position": [], "other" : "relevant"},
-            {"label": ["b", "f"],"position": [1,2], "other" : "field"},
-    ]
+        [
+            {"label": ["a", "b"],"position": [0,1],"other" : "not"},
+            {"label": ["a", "c", "d"], "position": [0,1,2], "other" : "relevant"},
+            {"label": ["a", "b", "f"], "position": [0,1,2], "other" : "field"}
+        ]
+
+        So the output would be:
+        [
+                {"label": ["b"], "position":[1],"other" : "not"},
+                {"label": [], "position": [], "other" : "relevant"},
+                {"label": ["b", "f"],"position": [1,2], "other" : "field"},
+        ]
 
     Args:
         field - the field to intersected (must contain list values)
@@ -2367,21 +2371,23 @@ class CollateInstancesByField(StreamOperator):
     Example:
         Collate the instances based on field "category" and aggregate fields "value" and "id".
 
-        CollateInstancesByField(by_field="category", aggregate_fields=["value", "id"])
+        .. code-block:: text
 
-        given input:
-        [
-            {"id": 1, "category": "A", "value": 10", "flag" : True},
-            {"id": 2, "category": "B", "value": 20", "flag" : False},
-            {"id": 3, "category": "A", "value": 30", "flag" : True},
-            {"id": 4, "category": "B", "value": 40", "flag" : False}
-        ]
+            CollateInstancesByField(by_field="category", aggregate_fields=["value", "id"])
 
-        the output is:
-        [
-            {"category": "A", "id": [1, 3], "value": [10, 30], "info": True},
-            {"category": "B", "id": [2, 4], "value": [20, 40], "info": False}
-        ]
+            given input:
+            [
+                {"id": 1, "category": "A", "value": 10", "flag" : True},
+                {"id": 2, "category": "B", "value": 20", "flag" : False},
+                {"id": 3, "category": "A", "value": 30", "flag" : True},
+                {"id": 4, "category": "B", "value": 40", "flag" : False}
+            ]
+
+            the output is:
+            [
+                {"category": "A", "id": [1, 3], "value": [10, 30], "info": True},
+                {"category": "B", "id": [2, 4], "value": [20, 40], "info": False}
+            ]
 
         Note that the "flag" field is not aggregated, and must be the same
         in all instances in the same category, or an error is raised.
@@ -2462,3 +2468,14 @@ class WikipediaFetcher(FieldOperator):
         page = self.wikipedia.page(title)
 
         return {"title": page.title, "body": getattr(page, self.mode)}
+
+class Fillna(FieldOperator):
+    value: Any
+    def process_value(self, value: Any) -> Any:
+        import numpy as np
+        try:
+            if np.isnan(value):
+                return self.value
+        except TypeError:
+            return value
+        return value

serializers.py

@@ -1,12 +1,13 @@
 import csv
 import io
+import json
 from abc import abstractmethod
 from typing import Any, Dict, List, Union
 
 from .dataclass import AbstractField, Field
-from .db_utils import get_db_connector
 from .operators import InstanceFieldOperator
 from .settings_utils import get_constants
+from .sql_utils import get_db_connector
 from .type_utils import isoftype, to_type_string
 from .types import (
     Dialog,
@@ -61,6 +62,13 @@ class ListSerializer(SingleTypeSerializer):
         return ", ".join(str(item) for item in value)
 
 
+class DictAsJsonSerializer(SingleTypeSerializer):
+    serialized_type = dict
+
+    def serialize(self, value: Any, instance: Dict[str, Any]) -> str:
+        return json.dumps(value)
+
+
 class DialogSerializer(SingleTypeSerializer):
     serialized_type = Dialog
 

settings_utils.py

@@ -151,11 +151,14 @@ if Settings.is_uninitilized():
     settings.mock_inference_mode = (bool, False)
     settings.disable_hf_datasets_cache = (bool, False)
     settings.stream_hf_datasets_by_default = (bool, False)
-
-    settings.loader_cache_size = (int, 10)
+    settings.loader_cache_size = (int, 25)
+    settings.loaders_max_retries = (int, 10)
     settings.task_data_as_text = (bool, True)
     settings.default_provider = "watsonx"
     settings.default_format = None
+    settings.hf_offline_datasets_path = None
+    settings.hf_offline_metrics_path = None
+    settings.hf_offline_models_path = None
 
 if Constants.is_uninitilized():
     constants = Constants()

db_utils.py → sql_utils.py

@@ -1,5 +1,6 @@
 import glob
 import os
+import re
 import sqlite3
 import time
 from abc import ABC, abstractmethod
@@ -47,10 +48,10 @@ def execute_query_local(db_path: str, query: str) -> Any:
         conn = sqlite3.connect(db_path)
         cursor = conn.cursor()
         cursor.execute(query)
-        return cursor.fetchall()
+        return cursor.fetchall(), None
     except sqlite3.Error as e:
         logger.info(f"Error executing SQL: {e}")
-        return None
+        return None, f"Error executing SQL: {e}"
     finally:
         if conn:
             conn.close()
@@ -178,10 +179,10 @@ class InMemoryDatabaseConnector(DatabaseConnector):
 
         try:
             cursor.execute(query)
-            return cursor.fetchall()
+            return cursor.fetchall(), None
         except sqlite3.Error as e:
             logger.info(f"Error executing SQL: {e}")
-            return None
+            return None, f"Error executing SQL: {e}"
         finally:
             conn.close()
 
@@ -196,7 +197,7 @@ def execute_query_remote(
     max_retries: int = 3,
     retry_delay: int = 5,  # seconds
     timeout: int = 30,  # seconds
-) -> Optional[dict]:
+) -> (Optional[dict], str):
     """Executes a query against the remote database, with retries for certain exceptions."""
     headers = {
         "Content-Type": "application/json",
@@ -210,11 +211,11 @@ def execute_query_remote(
                 f"{api_url}/sql",
                 headers=headers,
                 json={"sql": query, "dataSourceId": database_id},
-                verify=True,
+                verify=False,
                 timeout=timeout,
             )
             response.raise_for_status()
-            return response.json()
+            return response.json(), None
 
         except retryable_exceptions as e:
             retries += 1
@@ -225,7 +226,10 @@ def execute_query_remote(
                 time.sleep(retry_delay)
             else:
                 logger.error(f"Max retries ({max_retries}) exceeded for query: {query}")
-                return None
+                return (
+                    None,
+                    f"Max retries ({max_retries}) exceeded for query: {query} - Error: {e!s}",
+                )
 
         except requests.exceptions.HTTPError as e:
             if e.response.status_code >= 500:
@@ -239,16 +243,22 @@ def execute_query_remote(
                     logger.error(
                         f"Max retries ({max_retries}) exceeded for query: {query}"
                     )
-                    return None
+                    return (
+                        None,
+                        f"Max retries ({max_retries}) exceeded for query: {query} - Error: {e!s}",
+                    )
             else:
                 logger.error(f"HTTP Error on attempt {retries}: {e}")
-                return None
+                return (
+                    None,
+                    f"HTTP Error on attempt {retries}: {e}",
+                )
 
         except Exception as e:
             logger.error(f"Unexpected error on attempt {retries}: {e}")
-            return None
+            return (None, f"Unexpected error on attempt {retries}: {e}")
 
-    return None
+    return None, "Unknown Error in SQL execution"
 
 
 class RemoteDatabaseConnector(DatabaseConnector):
@@ -288,11 +298,11 @@ class RemoteDatabaseConnector(DatabaseConnector):
         self,
     ) -> str:
         """Retrieves the schema of a database."""
-        cur_api_url = f"{self.api_url}/datasource/{self.database_id}"
+        cur_api_url = f"{self.api_url}/datasources/{self.database_id}"
         response = requests.get(
             cur_api_url,
             headers=self.headers,
-            verify=True,
+            verify=False,
             timeout=self.timeout,
         )
         if response.status_code == 200:
@@ -330,3 +340,220 @@ def get_db_connector(db_type: str):
         raise ValueError(f"Unsupported database type: {db_type}")
 
     return connector
+
+
+def is_sqlglot_parsable(sql: str, db_type="sqlite") -> bool:
+    """Returns True if sqlglot does not encounter any error, False otherwise."""
+    from sqlglot import parse
+
+    if not sql.strip():
+        return False
+    if db_type == "db2":
+        db_type = "postgres"  ## TODO: temporary until sqlglot adds support for db2
+    try:
+        parse(sql, read=db_type)
+        return True
+    except Exception as e:
+        logger.debug(f"SQL query could not parse: {e}")
+        return False
+
+
+def is_sqlparse_parsable(sql: str) -> bool:
+    """Returns True if sqlparse does not encounter any error, False otherwise."""
+    from sqlparse import parse
+    from sqlparse.tokens import Error
+
+    if not sql.strip():
+        return False
+    try:
+        statements = parse(sql)
+        for statement in statements:
+            for token in statement.tokens:
+                if token.ttype == Error:
+                    return False
+        return True
+    except Exception as e:
+        logger.debug(f"SQL query could not parse: {e}")
+        return False
+
+
+def sqlglot_optimized_equivalence(expected: str, generated: str) -> int:
+    """Checks if SQL queries are equivalent using SQLGlot parsing, so we don't run them."""
+    from sqlglot import diff, parse_one
+    from sqlglot.optimizer import optimize
+
+    try:
+        t_diff = diff(
+            optimize(parse_one(expected.lower()).sql(pretty=True)),
+            optimize(parse_one(generated.lower()).sql(pretty=True)),
+        )
+        sql_diff = sum(0 if (e.__class__.__name__ == "Keep") else 1 for e in t_diff)
+
+        return 1 if sql_diff == 0 else 0
+    except Exception as e:
+        logger.debug(f"Error parsing SQL for comparison: {e}")
+        return False
+
+
+def extract_select_columns(statement):
+    """Parse SQL using sqlparse and extract columns."""
+    from sqlparse.sql import Identifier, IdentifierList
+    from sqlparse.tokens import DML, Keyword
+
+    columns = []
+    select_seen = False
+    for token in statement.tokens:
+        if token.ttype is DML and token.value.upper() == "SELECT":
+            select_seen = True
+            continue
+        if select_seen:
+            if token.ttype is Keyword and token.value.upper() in (
+                "FROM",
+                "WHERE",
+                "GROUP",
+                "HAVING",
+                "ORDER",
+                "LIMIT",
+            ):
+                break
+            if isinstance(token, IdentifierList):
+                for identifier in token.get_identifiers():
+                    columns.append(strip_alias(identifier.value))
+            elif isinstance(token, Identifier):
+                columns.append(strip_alias(token.value))
+            else:
+                val = token.value.strip()
+                if val:
+                    columns.append(strip_alias(val))
+    return frozenset(columns)
+
+
+def strip_alias(col: str) -> str:
+    """Remove any AS alias from a column."""
+    col = col.strip()
+    upper = col.upper()
+    if " AS " in upper:
+        return col[: upper.index(" AS ")].strip()
+    parts_alias = col.split()
+    if len(parts_alias) > 1:
+        return " ".join(parts_alias[:-1])
+    return col
+
+
+def collect_clause(statement, clause_keyword):
+    """Parse SQL statement and collect clauses."""
+    from sqlparse.tokens import Keyword
+
+    found = False
+    collected = []
+    for token in statement.tokens:
+        tvalue = token.value.upper()
+        if token.ttype is Keyword:
+            if tvalue.startswith(clause_keyword):
+                found = True
+                continue
+            if found and tvalue in (
+                "FROM",
+                "WHERE",
+                "GROUP",
+                "HAVING",
+                "ORDER",
+                "LIMIT",
+            ):
+                break
+        if found:
+            collected.append(token.value)
+    return " ".join(collected).strip()
+
+
+def extract_select_info(sql: str):
+    """Parse SQL using sqlparse and return a dict of extracted columns and clauses."""
+    from sqlparse import parse
+    from sqlparse.tokens import DML
+
+    statements = parse(sql)
+    if len(statements) != 1:
+        return None
+    stmt = statements[0]
+    if not any(t.ttype is DML and t.value.upper() == "SELECT" for t in stmt.tokens):
+        return None
+    parts = {
+        "columns": None,
+        "from": "",
+        "where": "",
+        "group": "",
+        "having": "",
+        "order": "",
+    }
+    columns = extract_select_columns(stmt)
+    if not columns:
+        columns = frozenset()
+    parts["columns"] = columns
+    parts["from"] = collect_clause(stmt, "FROM")
+    parts["where"] = collect_clause(stmt, "WHERE")
+    parts["group"] = collect_clause(stmt, "GROUP")
+    parts["having"] = collect_clause(stmt, "HAVING")
+    parts["order"] = collect_clause(stmt, "ORDER")
+    return parts
+
+
+def sqlparse_queries_equivalent(sql1: str, sql2: str) -> bool:
+    """Return True if both SQL queries are naively considered equivalent."""
+    try:
+        info1 = extract_select_info(sql1)
+        info2 = extract_select_info(sql2)
+        if not info1 or not info2:
+            return False
+        if info1["columns"] != info2["columns"]:
+            return False
+        for k in ["from", "where", "group", "having", "order"]:
+            if info1[k].replace(" ", "").upper() != info2[k].replace(" ", "").upper():
+                return False
+        return True
+    except Exception as e:
+        logger.debug(f"Errpr parsing SQL query for comparison: {e}")
+        return False
+
+
+def sqlglot_parsed_queries_equivalent(sql1: str, sql2: str, dialect: str = "") -> bool:
+    from sqlglot import exp, parse_one
+
+    try:
+        ast1 = parse_one(sql1, read=dialect)
+        ast2 = parse_one(sql2, read=dialect)
+    except:
+        return False
+    if not (isinstance(ast1, exp.Select) and isinstance(ast2, exp.Select)):
+        return False
+
+    def normalized_select_columns(select_expr: exp.Select):
+        cols = []
+        for item in select_expr.expressions:
+            copy_item = item.copy()
+            copy_item.set("alias", None)
+            cols.append(copy_item.sql(dialect=dialect, normalize=True))
+        return frozenset(cols)
+
+    if normalized_select_columns(ast1) != normalized_select_columns(ast2):
+        return False
+
+    def normalized_clause(expr: exp.Expression, key: str):
+        clause = expr.args.get(key)
+        return clause.sql(dialect=dialect, normalize=True) if clause else ""
+
+    for clause_key in ("from", "where", "group", "having", "order"):
+        if normalized_clause(ast1, clause_key) != normalized_clause(ast2, clause_key):
+            return False
+
+    return True
+
+
+def sql_exact_match(sql1: str, sql2: str) -> bool:
+    """Return True if two SQL strings match after very basic normalization."""
+
+    def normalize_sql(s: str) -> str:
+        s = s.strip().rstrip(";")
+        s = re.sub(r"\s+", " ", s)
+        return s.upper()
+
+    return normalize_sql(sql1) == normalize_sql(sql2)

standard.py

@@ -27,7 +27,12 @@ from .splitters import ConstantSizeSample, RandomSizeSample, Sampler
 from .stream import MultiStream
 from .system_prompts import EmptySystemPrompt, SystemPrompt
 from .task import Task
-from .templates import ApplyRandomTemplate, ApplySingleTemplate, Template, TemplatesList
+from .templates import (
+    ApplyRandomTemplate,
+    ApplySingleTemplate,
+    Template,
+    TemplatesList,
+)
 from .type_utils import isoftype
 from .utils import LRUCache, recursive_copy
 
@@ -658,35 +663,31 @@ class DatasetRecipe(SourceSequentialOperator):
 
         self.finalize.steps.append(FinalizeDataset(group_by=self.group_by))
 
+    @property
+    def has_card_templates(self):
+        return self.card is not None and self.card.templates is not None and len(self.card.templates) > 0
+
+    @property
+    def has_no_templates(self):
+        return self.template_card_index is None and self.template is None
+
     def prepare(self):
         assert (
             self.template_card_index is None or self.template is None
         ), f"Specify either template ({self.template}) or template_card_index ({self.template_card_index}) but not both"
 
-        if self.template_card_index is None and self.template is None:
-            # First try to use the defined defaults
-            if self.card.default_template is not None:
-                self.template = self.card.default_template
+        if self.has_no_templates:
+            if self.has_card_templates:
+                if isinstance(self.card.templates, list):
+                    self.template_card_index = 0
+                else:
+                    self.template_card_index = next(iter(self.card.templates.keys()))
+                logger.warning(
+                    "Template was not specified in recipe, using the first template from the card by default."
+                )
             else:
                 self.template = self.card.task.default_template
 
-            # Than try to infer the default
-            if self.template is None:
-                if (
-                    self.card is not None
-                    and self.card.templates is not None
-                    and len(self.card.templates) > 0
-                ):
-                    self.template_card_index = (
-                        0
-                        if isinstance(self.card.templates, list)
-                        else next(iter(self.card.templates.keys()))
-                    )
-                    logger.warning(
-                        "Template was not specified in recipe, using the first template from the card by default."
-                    )
-                else:
-                    self.template = self.card.task.default_template
 
         if self.template is None and self.template_card_index is not None:
             try:
@@ -704,6 +705,7 @@ class DatasetRecipe(SourceSequentialOperator):
             raise ValueError(
                 "No template was specified in the the 'template' or 'template_card_index' recipe arguments, and no default templates are defined the card or task"
             )
+
         if self.use_demos:
             assert (
                 self.demos_pool is not None
@@ -726,6 +728,7 @@ class DatasetRecipe(SourceSequentialOperator):
 
         if isinstance(self.template, TemplatesList):
             self.template = self.template.items
+
         self.reset_pipeline()
 
 

string_operators.py

@@ -1,3 +1,4 @@
+import os
 import re
 from typing import (
     Any,
@@ -7,7 +8,9 @@ from typing import (
 )
 
 from .operators import FieldOperator, InstanceOperator
+from .settings_utils import get_settings
 
+settings = get_settings()
 
 class Split(FieldOperator):
     by: str
@@ -30,8 +33,10 @@ class TokensSplit(FieldOperator):
     def prepare(self):
         super().prepare()
         from transformers import AutoTokenizer
-
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model)
+        path = self.model
+        if settings.hf_offline_models_path is not None:
+            path = os.path.join(settings.hf_offline_models_path, path)
+        self.tokenizer = AutoTokenizer.from_pretrained(path)
 
     def process_value(self, value: str) -> List[str]:
         return self.tokenizer.tokenize(value)
@@ -48,8 +53,10 @@ class TokensSlice(FieldOperator):
     def prepare(self):
         super().prepare()
         from transformers import AutoTokenizer
-
-        self.tokenizer = AutoTokenizer.from_pretrained(self.model)
+        path = self.model
+        if settings.hf_offline_models_path is not None:
+            path = os.path.join(settings.hf_offline_models_path, path)
+        self.tokenizer = AutoTokenizer.from_pretrained(path)
 
     def process_value(self, value: str) -> str:
         encoded = self.tokenizer.encode(value)

struct_data_operators.py

@@ -23,7 +23,6 @@ For key-value pairs, expected input format is:
     {"key1": "value1", "key2": value2, "key3": "value3"}
 """
 
-import ast
 import json
 import random
 from abc import ABC, abstractmethod
@@ -43,6 +42,7 @@ from .error_utils import UnitxtWarning
 from .operators import FieldOperator, InstanceOperator
 from .random_utils import new_random_generator
 from .serializers import ImageSerializer, TableSerializer
+from .type_utils import isoftype
 from .types import Table
 from .utils import recursive_copy
 
@@ -1025,16 +1025,21 @@ class ShuffleColumnsNames(TypeDependentAugmentor):
 
 
 class JsonStrToListOfKeyValuePairs(FieldOperator):
-    def process_value(self, text: str) -> List[Tuple[str, str]]:
-        text = text.replace("null", "None")
+    """Convert a Json string of representing key value as dictionary to list of key value pairs."""
 
+    def process_value(self, text: str) -> List[Tuple[str, str]]:
         try:
-            dict_value = ast.literal_eval(text)
+            dict_value = json.loads(text)
         except Exception as e:
             UnitxtWarning(
                 f"Unable to convert input text to json format in JsonStrToListOfKeyValuePairs due to {e}. Text: {text}"
             )
             dict_value = {}
+        if not isoftype(dict_value, Dict[str, Any]):
+            UnitxtWarning(
+                f"Unable to convert input text to dictionary in JsonStrToListOfKeyValuePairs. Text: {text}"
+            )
+            dict_value = {}
         return [
             (str(key), str(value))
             for key, value in dict_value.items()

version.py

@@ -1 +1 @@
-version = "1.18.0"
+version = "1.19.0"