diff --git a/src/evidently/features/text_contains_feature.py b/src/evidently/features/text_contains_feature.py
index 6b909b95c0..f1b9e6bd33 100644
--- a/src/evidently/features/text_contains_feature.py
+++ b/src/evidently/features/text_contains_feature.py
@@ -103,7 +103,7 @@ def generate_feature(self, data: pd.DataFrame, data_definition: DataDefinition)
     def _as_column(self) -> ColumnName:
         return self._create_column(
             self._feature_column_name(),
-            default_display_name=f"Text Contains of {self.mode} [{', '.join(self.items)}] for {self.column_name}",
+            default_display_name=f"Text Does Not Contain of {self.mode} [{', '.join(self.items)}] for {self.column_name}",
         )
 
     def comparison(self, item: str, string: str):
diff --git a/src/evidently/v2/datasets.py b/src/evidently/v2/datasets.py
index 7aa9cc489f..e24108edb9 100644
--- a/src/evidently/v2/datasets.py
+++ b/src/evidently/v2/datasets.py
@@ -37,7 +37,7 @@ def __init__(self, type: ColumnType, data: pd.Series) -> None:
         self.data = data
 
 
-class Scorer:
+class Descriptor:
     def __init__(self, alias: str):
         self._alias = alias
 
@@ -50,7 +50,7 @@ def alias(self) -> str:
         return self._alias
 
 
-class FeatureScorer(Scorer):
+class FeatureDescriptor(Descriptor):
     def __init__(self, feature: GeneratedFeatures, alias: Optional[str] = None):
         super().__init__(alias or f"{feature.as_column().display_name}")
         self._feature = feature
@@ -67,7 +67,7 @@ def generate_data(self, dataset: "Dataset") -> Union[DatasetColumn, Dict[str, Da
         return DatasetColumn(type=self._feature.get_type(), data=feature[feature.columns[0]])
 
 
-def _determine_scorer_column_name(alias: str, columns: List[str]):
+def _determine_desccriptor_column_name(alias: str, columns: List[str]):
     index = 1
     key = alias
     while key in columns:
@@ -84,12 +84,12 @@ def from_pandas(
         cls,
         data: pd.DataFrame,
         data_definition: Optional[DataDefinition] = None,
-        scorers: Optional[List[Scorer]] = None,
+        descriptors: Optional[List[Descriptor]] = None,
     ) -> "Dataset":
         dataset = PandasDataset(data, data_definition)
-        for scorer in scorers or []:
-            key = _determine_scorer_column_name(scorer.alias, data.columns)
-            new_column = scorer.generate_data(dataset)
+        for descriptor in descriptors or []:
+            key = _determine_desccriptor_column_name(descriptor.alias, data.columns)
+            new_column = descriptor.generate_data(dataset)
             if isinstance(new_column, DatasetColumn):
                 data[key] = new_column.data
             elif len(new_column) > 1:
diff --git a/src/evidently/v2/scorers/__init__.py b/src/evidently/v2/scorers/__init__.py
index 4efe430305..2a53f5618e 100644
--- a/src/evidently/v2/scorers/__init__.py
+++ b/src/evidently/v2/scorers/__init__.py
@@ -1,41 +1,42 @@
-from ._custom_scorers import CustomColumnScorer
-from ._custom_scorers import CustomScorer
+from ._custom_descriptors import CustomColumnDescriptor
+from ._custom_descriptors import CustomDescriptor
 from ._text_length import TextLength
-from .generated_scorers import begins_with
-from .generated_scorers import bert_score
-from .generated_scorers import contains
-from .generated_scorers import contains_link
-from .generated_scorers import does_not_contain
-from .generated_scorers import ends_with
-from .generated_scorers import exact_match
-from .generated_scorers import excludes_words
-from .generated_scorers import hugging_face
-from .generated_scorers import hugging_face_toxicity
-from .generated_scorers import includes_words
-from .generated_scorers import is_valid_json
-from .generated_scorers import is_valid_python
-from .generated_scorers import item_match
-from .generated_scorers import item_no_match
-from .generated_scorers import json_match
-from .generated_scorers import json_schema_match
-from .generated_scorers import llm_judge
-from .generated_scorers import non_letter_character_percentage
-from .generated_scorers import oov_words_percentage
-from .generated_scorers import openai
-from .generated_scorers import reg_exp
-from .generated_scorers import semantic_similarity
-from .generated_scorers import sentence_count
-from .generated_scorers import sentiment
-from .generated_scorers import text_length
-from .generated_scorers import trigger_words_present
-from .generated_scorers import word_count
-from .generated_scorers import word_match
-from .generated_scorers import word_no_match
-from .generated_scorers import words_presence
+from .generated_descriptors import begins_with
+from .generated_descriptors import bert_score
+from .generated_descriptors import contains
+from .generated_descriptors import contains_link
+from .generated_descriptors import does_not_contain
+from .generated_descriptors import ends_with
+from .generated_descriptors import exact_match
+from .generated_descriptors import excludes_words
+from .generated_descriptors import hugging_face
+from .generated_descriptors import hugging_face_toxicity
+from .generated_descriptors import includes_words
+from .generated_descriptors import is_valid_json
+from .generated_descriptors import is_valid_python
+from .generated_descriptors import is_valid_sql
+from .generated_descriptors import item_match
+from .generated_descriptors import item_no_match
+from .generated_descriptors import json_match
+from .generated_descriptors import json_schema_match
+from .generated_descriptors import llm_judge
+from .generated_descriptors import non_letter_character_percentage
+from .generated_descriptors import oov_words_percentage
+from .generated_descriptors import openai
+from .generated_descriptors import reg_exp
+from .generated_descriptors import semantic_similarity
+from .generated_descriptors import sentence_count
+from .generated_descriptors import sentiment
+from .generated_descriptors import text_length
+from .generated_descriptors import trigger_words_present
+from .generated_descriptors import word_count
+from .generated_descriptors import word_match
+from .generated_descriptors import word_no_match
+from .generated_descriptors import words_presence
 
 __all__ = [
-    "CustomColumnScorer",
-    "CustomScorer",
+    "CustomColumnDescriptor",
+    "CustomDescriptor",
     "TextLength",
     "bert_score",
     "begins_with",
@@ -50,6 +51,7 @@
     "includes_words",
     "is_valid_json",
     "is_valid_python",
+    "is_valid_sql",
     "item_match",
     "item_no_match",
     "json_match",
diff --git a/src/evidently/v2/scorers/_custom_scorers.py b/src/evidently/v2/scorers/_custom_descriptors.py
similarity index 88%
rename from src/evidently/v2/scorers/_custom_scorers.py
rename to src/evidently/v2/scorers/_custom_descriptors.py
index 8db15bac38..7e1042471a 100644
--- a/src/evidently/v2/scorers/_custom_scorers.py
+++ b/src/evidently/v2/scorers/_custom_descriptors.py
@@ -5,10 +5,10 @@
 
 from evidently.v2.datasets import Dataset
 from evidently.v2.datasets import DatasetColumn
-from evidently.v2.datasets import Scorer
+from evidently.v2.datasets import Descriptor
 
 
-class CustomColumnScorer(Scorer):
+class CustomColumnDescriptor(Descriptor):
     def __init__(self, column_name: str, func: Callable[[DatasetColumn], DatasetColumn], alias: Optional[str] = None):
         super().__init__(alias)
         self._column_name = column_name
@@ -19,7 +19,7 @@ def generate_data(self, dataset: Dataset) -> Union[DatasetColumn, Dict[str, Data
         return self._func(column_data)
 
 
-class CustomScorer(Scorer):
+class CustomDescriptor(Descriptor):
     def __init__(
         self, func: Callable[[Dataset], Union[DatasetColumn, Dict[str, DatasetColumn]]], alias: Optional[str] = None
     ):
diff --git a/src/evidently/v2/scorers/_generate_scorers.py b/src/evidently/v2/scorers/_generate_descriptors.py
similarity index 92%
rename from src/evidently/v2/scorers/_generate_scorers.py
rename to src/evidently/v2/scorers/_generate_descriptors.py
index 9050ad82c7..7f1fb577eb 100644
--- a/src/evidently/v2/scorers/_generate_scorers.py
+++ b/src/evidently/v2/scorers/_generate_descriptors.py
@@ -19,9 +19,9 @@
 from evidently.features.generated_features import GeneratedFeatures
 from evidently.features.llm_judge import BaseLLMPromptTemplate
 from evidently.pydantic_utils import TYPE_ALIASES
-from evidently.v2.datasets import FeatureScorer
+from evidently.v2.datasets import FeatureDescriptor
 
-SOURCE_FILE = "generated_scorers.py"
+SOURCE_FILE = "generated_descriptors.py"
 
 REPLACES = {
     "pandas.core.frame.DataFrame": "DataFrame",
@@ -29,7 +29,11 @@
     "pandas.core.series.Series": "Series",
 }
 
-NAME_MAPPING = {"open_a_i_feature": "openai_feature", "is_valid_j_s_o_n": "is_valid_json"}
+NAME_MAPPING = {
+    "open_a_i_feature": "openai_feature",
+    "is_valid_j_s_o_n": "is_valid_json",
+    "is_valid_s_q_l": "is_valid_sql",
+}
 
 SKIP_CLASSES = {CustomFeature, CustomPairColumnFeature, CustomSingleColumnFeature}
 
@@ -80,7 +84,7 @@ def get_args_kwargs(feature_class: Type[GeneratedFeatures]) -> Tuple[Dict[str, s
     return args, kwargs
 
 
-def create_scorer_function(feature_class: Type[GeneratedFeatures]):
+def create_descriptor_function(feature_class: Type[GeneratedFeatures]):
     class_name = feature_class.__name__
     cmpx = os.path.commonprefix([class_name, class_name.upper()])[:-2]
     name = cmpx.lower() + re.sub(r"(?<!^)(?=[A-Z])", "_", class_name[len(cmpx) :]).lower()
@@ -116,7 +120,7 @@ def main():
     srcs = []
     fnames = []
     imports: List[Type] = [
-        FeatureScorer,
+        FeatureDescriptor,
         ColumnType,
         BaseLLMPromptTemplate,
         Any,
@@ -129,7 +133,7 @@ def main():
             continue
         if feature_class in SKIP_CLASSES:
             continue
-        src, fname = create_scorer_function(feature_class)
+        src, fname = create_descriptor_function(feature_class)
         fnames.append(fname)
         srcs.append(src)
         imports.append(feature_class)
diff --git a/src/evidently/v2/scorers/_text_length.py b/src/evidently/v2/scorers/_text_length.py
index 970e99ef03..895e92aefd 100644
--- a/src/evidently/v2/scorers/_text_length.py
+++ b/src/evidently/v2/scorers/_text_length.py
@@ -5,10 +5,10 @@
 from evidently import ColumnType
 from evidently.v2.datasets import Dataset
 from evidently.v2.datasets import DatasetColumn
-from evidently.v2.datasets import Scorer
+from evidently.v2.datasets import Descriptor
 
 
-class TextLength(Scorer):
+class TextLength(Descriptor):
     def __init__(self, column_name: str, alias: Optional[str] = None):
         super().__init__(alias)
         self._column_name: str = column_name
diff --git a/src/evidently/v2/scorers/generated_scorers.py b/src/evidently/v2/scorers/generated_descriptors.py
similarity index 82%
rename from src/evidently/v2/scorers/generated_scorers.py
rename to src/evidently/v2/scorers/generated_descriptors.py
index 2bd123c5f6..c8d9e9b16a 100644
--- a/src/evidently/v2/scorers/generated_scorers.py
+++ b/src/evidently/v2/scorers/generated_descriptors.py
@@ -11,6 +11,7 @@
 from evidently.features.hf_feature import HuggingFaceToxicityFeature
 from evidently.features.is_valid_json_feature import IsValidJSON
 from evidently.features.is_valid_python_feature import IsValidPython
+from evidently.features.is_valid_sql_feature import IsValidSQL
 from evidently.features.json_match_feature import JSONMatch
 from evidently.features.json_schema_match_feature import JSONSchemaMatch
 from evidently.features.llm_judge import BaseLLMPromptTemplate
@@ -36,60 +37,60 @@
 from evidently.features.words_feature import WordMatch
 from evidently.features.words_feature import WordNoMatch
 from evidently.features.words_feature import WordsPresence
-from evidently.v2.datasets import FeatureScorer
+from evidently.v2.datasets import FeatureDescriptor
 
 
 def bert_score(
     columns: List[str], model: str = "bert-base-uncased", tfidf_weighted: bool = False, alias: Optional[str] = None
 ):
     feature = BERTScoreFeature(columns=columns, model=model, tfidf_weighted=tfidf_weighted)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def begins_with(column_name: str, prefix: str, case_sensitive: bool = True, alias: Optional[str] = None):
     feature = BeginsWith(column_name=column_name, prefix=prefix, case_sensitive=case_sensitive)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def contains(
     column_name: str, items: List[str], case_sensitive: bool = True, mode: str = "any", alias: Optional[str] = None
 ):
     feature = Contains(column_name=column_name, items=items, case_sensitive=case_sensitive, mode=mode)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def contains_link(column_name: str, alias: Optional[str] = None):
     feature = ContainsLink(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def does_not_contain(
     column_name: str, items: List[str], case_sensitive: bool = True, mode: str = "any", alias: Optional[str] = None
 ):
     feature = DoesNotContain(column_name=column_name, items=items, case_sensitive=case_sensitive, mode=mode)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def ends_with(column_name: str, suffix: str, case_sensitive: bool = True, alias: Optional[str] = None):
     feature = EndsWith(column_name=column_name, suffix=suffix, case_sensitive=case_sensitive)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def exact_match(columns: List[str], alias: Optional[str] = None):
     feature = ExactMatchFeature(columns=columns)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def excludes_words(
     column_name: str, words_list: List[str], mode: str = "any", lemmatize: bool = True, alias: Optional[str] = None
 ):
     feature = ExcludesWords(column_name=column_name, words_list=words_list, mode=mode, lemmatize=lemmatize)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def hugging_face(column_name: str, model: str, params: dict, display_name: str, alias: Optional[str] = None):
     feature = HuggingFaceFeature(column_name=column_name, model=model, params=params, display_name=display_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def hugging_face_toxicity(
@@ -102,34 +103,39 @@ def hugging_face_toxicity(
     feature = HuggingFaceToxicityFeature(
         column_name=column_name, display_name=display_name, model=model, toxic_label=toxic_label
     )
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def includes_words(
     column_name: str, words_list: List[str], mode: str = "any", lemmatize: bool = True, alias: Optional[str] = None
 ):
     feature = IncludesWords(column_name=column_name, words_list=words_list, mode=mode, lemmatize=lemmatize)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def is_valid_json(column_name: str, alias: Optional[str] = None):
     feature = IsValidJSON(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def is_valid_python(column_name: str, alias: Optional[str] = None):
     feature = IsValidPython(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
+
+
+def is_valid_sql(column_name: str, alias: Optional[str] = None):
+    feature = IsValidSQL(column_name=column_name)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def item_match(columns: List[str], case_sensitive: bool = True, mode: str = "any", alias: Optional[str] = None):
     feature = ItemMatch(columns=columns, case_sensitive=case_sensitive, mode=mode)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def item_no_match(columns: List[str], case_sensitive: bool = True, mode: str = "any", alias: Optional[str] = None):
     feature = ItemNoMatch(columns=columns, case_sensitive=case_sensitive, mode=mode)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def json_match(
@@ -139,7 +145,7 @@ def json_match(
     alias: Optional[str] = None,
 ):
     feature = JSONMatch(first_column=first_column, second_column=second_column, feature_type=feature_type)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def json_schema_match(
@@ -152,7 +158,7 @@ def json_schema_match(
     feature = JSONSchemaMatch(
         column_name=column_name, expected_schema=expected_schema, validate_types=validate_types, exact_match=exact_match
     )
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def llm_judge(
@@ -166,17 +172,17 @@ def llm_judge(
     feature = LLMJudge(
         provider=provider, model=model, template=template, input_column=input_column, input_columns=input_columns
     )
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def non_letter_character_percentage(column_name: str, alias: Optional[str] = None):
     feature = NonLetterCharacterPercentage(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def oov_words_percentage(column_name: str, ignore_words: Any = (), alias: Optional[str] = None):
     feature = OOVWordsPercentage(column_name=column_name, ignore_words=ignore_words)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def openai(
@@ -206,56 +212,56 @@ def openai(
         possible_values=possible_values,
         openai_params=openai_params,
     )
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def reg_exp(column_name: str, reg_exp: str, alias: Optional[str] = None):
     feature = RegExp(column_name=column_name, reg_exp=reg_exp)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def semantic_similarity(columns: List[str], model: str = "all-MiniLM-L6-v2", alias: Optional[str] = None):
     feature = SemanticSimilarityFeature(columns=columns, model=model)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def sentence_count(column_name: str, alias: Optional[str] = None):
     feature = SentenceCount(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def sentiment(column_name: str, alias: Optional[str] = None):
     feature = Sentiment(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def text_length(column_name: str, alias: Optional[str] = None):
     feature = TextLength(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def trigger_words_present(column_name: str, words_list: List[str], lemmatize: bool = True, alias: Optional[str] = None):
     feature = TriggerWordsPresent(column_name=column_name, words_list=words_list, lemmatize=lemmatize)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def word_count(column_name: str, alias: Optional[str] = None):
     feature = WordCount(column_name=column_name)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def word_match(columns: List[str], mode: str, lemmatize: bool, alias: Optional[str] = None):
     feature = WordMatch(columns=columns, mode=mode, lemmatize=lemmatize)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def word_no_match(columns: List[str], mode: str, lemmatize: bool, alias: Optional[str] = None):
     feature = WordNoMatch(columns=columns, mode=mode, lemmatize=lemmatize)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
 
 
 def words_presence(
     column_name: str, words_list: List[str], mode: str = "any", lemmatize: bool = True, alias: Optional[str] = None
 ):
     feature = WordsPresence(column_name=column_name, words_list=words_list, mode=mode, lemmatize=lemmatize)
-    return FeatureScorer(feature, alias=alias)
+    return FeatureDescriptor(feature, alias=alias)
diff --git a/src/evidently/v2/scorers/showcase.ipynb b/src/evidently/v2/scorers/showcase.ipynb
new file mode 100644
index 0000000000..42567ef3fa
--- /dev/null
+++ b/src/evidently/v2/scorers/showcase.ipynb
@@ -0,0 +1,152 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2024-12-17T02:29:44.774515Z",
+     "start_time": "2024-12-17T02:29:44.769888Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from evidently.v2.datasets import Dataset\n",
+    "from evidently.v2.scorers import begins_with, bert_score, contains, contains_link, does_not_contain, ends_with, exact_match, excludes_words, \\\n",
+    "    hugging_face, hugging_face_toxicity, includes_words, is_valid_json, is_valid_python, item_match, item_no_match, json_match, \\\n",
+    "    json_schema_match, llm_judge, non_letter_character_percentage, oov_words_percentage, openai, reg_exp, semantic_similarity, \\\n",
+    "    sentence_count, sentiment, text_length, trigger_words_present, word_count, word_match, word_no_match, words_presence\n",
+    "import pandas as pd"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "outputs": [],
+   "source": [
+    "df = pd.DataFrame({\"str1\": [\"first value\",\n",
+    "                            \"second value\",\n",
+    "                            \"third value\",\n",
+    "                            \"fourth value\"],\n",
+    "                   \"str2\": [\"first value\",\n",
+    "                            \"http://localhost.com\",\n",
+    "                            \"{\\\"a\\\":\\\"b\\\"}\",\n",
+    "                            \"import evidently\"],\n",
+    "                   })"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-12-17T02:40:12.923487Z",
+     "start_time": "2024-12-17T02:40:12.920273Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "outputs": [],
+   "source": [
+    "dataset = Dataset.from_pandas(\n",
+    "    df,\n",
+    "    scorers=[\n",
+    "        begins_with(\"str1\", \"first\"),\n",
+    "        bert_score([\"str1\", \"str2\"]),\n",
+    "        contains(\"str1\", [\"first\"]),\n",
+    "        contains_link(\"str2\"),\n",
+    "        does_not_contain(\"str1\", [\"second\"]),\n",
+    "        ends_with(\"str1\", \"value\"),\n",
+    "        exact_match([\"str1\", \"str2\"]),\n",
+    "        excludes_words(\"str1\", [\"second\"]),\n",
+    "        # hugging_face(\"str1\"),\n",
+    "        # hugging_face_toxicity(\"str1\"),\n",
+    "        includes_words(\"str1\", [\"second\"]),\n",
+    "        is_valid_json(\"str2\"),\n",
+    "        is_valid_python(\"str2\"),\n",
+    "        item_match([\"str1\", \"str2\"]),\n",
+    "        item_no_match([\"str1\", \"str2\"]),\n",
+    "        # json_match(\"str1\"),\n",
+    "        # json_schema_match(\"str1\"),\n",
+    "        # llm_judge(\"str1\"),\n",
+    "        non_letter_character_percentage(\"str2\"),\n",
+    "        oov_words_percentage(\"str1\"),\n",
+    "        # openai(\"str1\"),\n",
+    "        reg_exp(\"str1\", \".*value\"),\n",
+    "        semantic_similarity([\"str1\", \"str2\"]),\n",
+    "        sentence_count(\"str1\"),\n",
+    "        sentiment(\"str1\"),\n",
+    "        text_length(\"str1\"),\n",
+    "        trigger_words_present(\"str1\", [\"first\"]),\n",
+    "        word_count(\"str1\"),\n",
+    "        word_match([\"str1\", \"str2\"], \"includes_any\", True),\n",
+    "        word_no_match([\"str1\", \"str2\"], \"includes_any\", True),\n",
+    "        # words_presence(\"str1\", [\"first\"], \"includes_any\")\n",
+    "    ]\n",
+    ")"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-12-17T02:41:58.213170Z",
+     "start_time": "2024-12-17T02:41:47.468436Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "outputs": [
+    {
+     "data": {
+      "text/plain": "           str1                  str2  Text Begins with [first] for str1  \\\n0   first value           first value                               True   \n1  second value  http://localhost.com                              False   \n2   third value             {\"a\":\"b\"}                              False   \n3  fourth value      import evidently                              False   \n\n   Text Begins with [first] for str1_1  BERTScore for str1 str2.  \\\n0                                 True                  0.859864   \n1                                False                  0.442877   \n2                                False                  0.494391   \n3                                False                  0.658955   \n\n   Text Contains of any [first] for str1  str2 contains link  \\\n0                                   True               False   \n1                                  False                True   \n2                                  False               False   \n3                                  False               False   \n\n   Text Contains of any [second] for str1  Text Ends with [value] for str1  \\\n0                                    True                             True   \n1                                   False                             True   \n2                                    True                             True   \n3                                    True                             True   \n\n   Exact Match for str1 str2.  ...  OOV Words % for str1  \\\n0                        True  ...                   0.0   \n1                       False  ...                   0.0   \n2                       False  ...                   0.0   \n3                       False  ...                   0.0   \n\n   RegExp '.*value' Match for column str1  Semantic Similarity for str1 str2.  \\\n0                                       1                            1.000000   \n1                                       1                            0.490672   \n2                                       1                            0.590310   \n3                                       1                            0.548347   \n\n   Sentence Count for str1  Sentiment for str1  Text Length for str1  \\\n0                        1                0.34                    11   \n1                        1                0.34                    12   \n2                        1                0.34                    11   \n3                        1                0.34                    12   \n\n   TriggerWordsPresent [words: ['first'], lemmatize: True] for str1  \\\n0                                                  1                  \n1                                                  0                  \n2                                                  0                  \n3                                                  0                  \n\n   Word Count for str1  Text contains includes defined words  \\\n0                    2                                 False   \n1                    2                                 False   \n2                    2                                 False   \n3                    2                                 False   \n\n   Text does not contain includes defined words  \n0                                          True  \n1                                          True  \n2                                          True  \n3                                          True  \n\n[4 rows x 27 columns]",
+      "text/html": "<div>\n<style scoped>\n    .dataframe tbody tr th:only-of-type {\n        vertical-align: middle;\n    }\n\n    .dataframe tbody tr th {\n        vertical-align: top;\n    }\n\n    .dataframe thead th {\n        text-align: right;\n    }\n</style>\n<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: right;\">\n      <th></th>\n      <th>str1</th>\n      <th>str2</th>\n      <th>Text Begins with [first] for str1</th>\n      <th>Text Begins with [first] for str1_1</th>\n      <th>BERTScore for str1 str2.</th>\n      <th>Text Contains of any [first] for str1</th>\n      <th>str2 contains link</th>\n      <th>Text Contains of any [second] for str1</th>\n      <th>Text Ends with [value] for str1</th>\n      <th>Exact Match for str1 str2.</th>\n      <th>...</th>\n      <th>OOV Words % for str1</th>\n      <th>RegExp '.*value' Match for column str1</th>\n      <th>Semantic Similarity for str1 str2.</th>\n      <th>Sentence Count for str1</th>\n      <th>Sentiment for str1</th>\n      <th>Text Length for str1</th>\n      <th>TriggerWordsPresent [words: ['first'], lemmatize: True] for str1</th>\n      <th>Word Count for str1</th>\n      <th>Text contains includes defined words</th>\n      <th>Text does not contain includes defined words</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <th>0</th>\n      <td>first value</td>\n      <td>first value</td>\n      <td>True</td>\n      <td>True</td>\n      <td>0.859864</td>\n      <td>True</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>True</td>\n      <td>...</td>\n      <td>0.0</td>\n      <td>1</td>\n      <td>1.000000</td>\n      <td>1</td>\n      <td>0.34</td>\n      <td>11</td>\n      <td>1</td>\n      <td>2</td>\n      <td>False</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>1</th>\n      <td>second value</td>\n      <td>http://localhost.com</td>\n      <td>False</td>\n      <td>False</td>\n      <td>0.442877</td>\n      <td>False</td>\n      <td>True</td>\n      <td>False</td>\n      <td>True</td>\n      <td>False</td>\n      <td>...</td>\n      <td>0.0</td>\n      <td>1</td>\n      <td>0.490672</td>\n      <td>1</td>\n      <td>0.34</td>\n      <td>12</td>\n      <td>0</td>\n      <td>2</td>\n      <td>False</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>2</th>\n      <td>third value</td>\n      <td>{\"a\":\"b\"}</td>\n      <td>False</td>\n      <td>False</td>\n      <td>0.494391</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>...</td>\n      <td>0.0</td>\n      <td>1</td>\n      <td>0.590310</td>\n      <td>1</td>\n      <td>0.34</td>\n      <td>11</td>\n      <td>0</td>\n      <td>2</td>\n      <td>False</td>\n      <td>True</td>\n    </tr>\n    <tr>\n      <th>3</th>\n      <td>fourth value</td>\n      <td>import evidently</td>\n      <td>False</td>\n      <td>False</td>\n      <td>0.658955</td>\n      <td>False</td>\n      <td>False</td>\n      <td>True</td>\n      <td>True</td>\n      <td>False</td>\n      <td>...</td>\n      <td>0.0</td>\n      <td>1</td>\n      <td>0.548347</td>\n      <td>1</td>\n      <td>0.34</td>\n      <td>12</td>\n      <td>0</td>\n      <td>2</td>\n      <td>False</td>\n      <td>True</td>\n    </tr>\n  </tbody>\n</table>\n<p>4 rows × 27 columns</p>\n</div>"
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "dataset.as_dataframe()"
+   ],
+   "metadata": {
+    "collapsed": false,
+    "ExecuteTime": {
+     "end_time": "2024-12-17T02:42:19.272157Z",
+     "start_time": "2024-12-17T02:42:19.250853Z"
+    }
+   }
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "outputs": [],
+   "source": [],
+   "metadata": {
+    "collapsed": false
+   }
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}