judgeval 0.0.31__py3-none-any.whl → 0.0.33__py3-none-any.whl

judgeval/constants.py

@@ -43,7 +43,7 @@ JUDGMENT_EVAL_API_URL = f"{ROOT_API}/evaluate/"
 JUDGMENT_SEQUENCE_EVAL_API_URL = f"{ROOT_API}/evaluate_sequence/"
 JUDGMENT_DATASETS_PUSH_API_URL = f"{ROOT_API}/datasets/push/"
 JUDGMENT_DATASETS_APPEND_API_URL = f"{ROOT_API}/datasets/insert_examples/"
-JUDGMENT_DATASETS_PULL_API_URL = f"{ROOT_API}/datasets/pull/"
+JUDGMENT_DATASETS_PULL_API_URL = f"{ROOT_API}/datasets/pull_for_judgeval/"
 JUDGMENT_DATASETS_DELETE_API_URL = f"{ROOT_API}/datasets/delete/"
 JUDGMENT_DATASETS_EXPORT_JSONL_API_URL = f"{ROOT_API}/datasets/export_jsonl/"
 JUDGMENT_DATASETS_PROJECT_STATS_API_URL = f"{ROOT_API}/datasets/fetch_stats_by_project/"

judgeval/data/datasets/dataset.py

@@ -7,12 +7,13 @@ import yaml
 from dataclasses import dataclass, field
 from typing import List, Union, Literal
 
-from judgeval.data import Example
+from judgeval.data import Example, Sequence
 from judgeval.common.logger import debug, error, warning, info
 
 @dataclass
 class EvalDataset:
     examples: List[Example]
+    sequences: List[Sequence]
     _alias: Union[str, None] = field(default=None)
     _id: Union[str, None] = field(default=None)
     judgment_api_key: str = field(default="")
@@ -21,11 +22,13 @@ class EvalDataset:
                  judgment_api_key: str = os.getenv("JUDGMENT_API_KEY"),  
                  organization_id: str = os.getenv("JUDGMENT_ORG_ID"),
                  examples: List[Example] = [],
+                 sequences: List[Sequence] = []
                  ):
         debug(f"Initializing EvalDataset with {len(examples)} examples")
         if not judgment_api_key:
             warning("No judgment_api_key provided")
         self.examples = examples
+        self.sequences = sequences
         self._alias = None
         self._id = None
         self.judgment_api_key = judgment_api_key
@@ -309,6 +312,7 @@ class EvalDataset:
         return (
             f"{self.__class__.__name__}("
             f"examples={self.examples}, "
+            f"sequences={self.sequences}, "
             f"_alias={self._alias}, "
             f"_id={self._id}"
             f")"

judgeval/data/datasets/eval_dataset_client.py

@@ -13,7 +13,7 @@ from judgeval.constants import (
     JUDGMENT_DATASETS_INSERT_API_URL,
     JUDGMENT_DATASETS_EXPORT_JSONL_API_URL
 )
-from judgeval.data import Example
+from judgeval.data import Example, Sequence
 from judgeval.data.datasets import EvalDataset
 
 
@@ -201,8 +201,8 @@ class EvalDatasetClient:
 
                 info(f"Successfully pulled dataset with alias '{alias}'")
                 payload = response.json()
-
                 dataset.examples = [Example(**e) for e in payload.get("examples", [])]
+                dataset.sequences = [Sequence(**s) for s in payload.get("sequences", [])]
                 dataset._alias = payload.get("alias")
                 dataset._id = payload.get("id")
                 progress.update(

judgeval/data/sequence.py

@@ -1,7 +1,7 @@
 from pydantic import BaseModel, Field, field_validator, model_validator
 from typing import List, Optional, Union, Any
 from judgeval.data.example import Example
-from judgeval.scorers import ScorerWrapper, JudgevalScorer
+from judgeval.scorers import JudgevalScorer, APIJudgmentScorer
 from uuid import uuid4
 from datetime import datetime, timezone
 
@@ -16,42 +16,32 @@ class Sequence(BaseModel):
     scorers: Optional[Any] = None
     parent_sequence_id: Optional[str] = None
     sequence_order: Optional[int] = 0
+    root_sequence_id: Optional[str] = None
+    inputs: Optional[str] = None
+    output: Optional[str] = None
 
     @field_validator("scorers")
     def validate_scorer(cls, v):
-        loaded_scorers = []
         for scorer in v or []:
-            try:
-                if isinstance(scorer, ScorerWrapper):
-                    loaded_scorers.append(scorer.load_implementation())
-                else:
-                    loaded_scorers.append(scorer)
-            except Exception as e:
-                raise ValueError(f"Failed to load implementation for scorer {scorer}: {str(e)}")
-        return loaded_scorers
+            if not isinstance(scorer, APIJudgmentScorer) and not isinstance(scorer, JudgevalScorer):
+                raise ValueError(f"Invalid scorer type: {type(scorer)}")
+        return v
     
-    @model_validator(mode='after')
-    def set_parent_sequence_ids(self) -> "Sequence":
-        """Recursively set the parent_sequence_id for all nested Sequences."""
-        for item in self.items:
-            if isinstance(item, Sequence):
-                item.parent_sequence_id = self.sequence_id
-                # Recurse into deeper nested sequences
-                item.set_parent_sequence_ids()  
-        return self
+    @model_validator(mode="after")
+    def populate_sequence_metadata(self) -> "Sequence":
+        """Recursively set parent_sequence_id, root_sequence_id, and sequence_order."""
+        # If root_sequence_id isn't already set, assign it to self
+        if self.root_sequence_id is None:
+            self.root_sequence_id = self.sequence_id
 
-    @model_validator(mode='after')
-    def set_parent_and_order(self) -> "Sequence":
-        """Set parent_sequence_id and sequence_order for all items."""
         for idx, item in enumerate(self.items):
-            # Set sequence_order for both Example and Sequence objects
             item.sequence_order = idx
-            
             if isinstance(item, Sequence):
                 item.parent_sequence_id = self.sequence_id
-                item.set_parent_and_order()  # Recurse for nested sequences
+                item.root_sequence_id = self.root_sequence_id
+                item.populate_sequence_metadata()
         return self
-    
+
     class Config:
         arbitrary_types_allowed = True
 

judgeval/data/sequence_run.py

@@ -21,6 +21,7 @@ class SequenceRun(BaseModel):
         metadata (Optional[Dict[str, Any]]): Additional metadata to include for this evaluation run, e.g. comments, dataset name, purpose, etc.
         judgment_api_key (Optional[str]): The API key for running evaluations on the Judgment API
         rules (Optional[List[Rule]]): Rules to evaluate against scoring results
+        append (Optional[bool]): Whether to append to existing evaluation results
     """
 
     # The user will specify whether they want log_results when they call run_eval
@@ -33,6 +34,7 @@ class SequenceRun(BaseModel):
     aggregator: Optional[str] = None
     metadata: Optional[Dict[str, Any]] = None
     trace_span_id: Optional[str] = None
+    append: Optional[bool] = False
     # API Key will be "" until user calls client.run_eval(), then API Key will be set
     judgment_api_key: Optional[str] = ""
     override: Optional[bool] = False

judgeval/judgment_client.py

@@ -17,7 +17,6 @@ from judgeval.scorers import (
     APIJudgmentScorer, 
     JudgevalScorer, 
     ClassifierScorer, 
-    ScorerWrapper,
 )
 from judgeval.evaluation_run import EvaluationRun
 from judgeval.run_evaluation import (
@@ -74,7 +73,7 @@ class JudgmentClient(metaclass=SingletonMeta):
     def a_run_evaluation(
         self, 
         examples: List[Example],
-        scorers: List[Union[ScorerWrapper, JudgevalScorer]],
+        scorers: List[Union[APIJudgmentScorer, JudgevalScorer]],
         model: Union[str, List[str], JudgevalJudge],
         aggregator: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
@@ -83,49 +82,57 @@ class JudgmentClient(metaclass=SingletonMeta):
         eval_run_name: str = "default_eval_run",
         override: bool = False,
         append: bool = False,
-        use_judgment: bool = True,
         ignore_errors: bool = True,
         rules: Optional[List[Rule]] = None
     ) -> List[ScoringResult]:
-        return self.run_evaluation(examples, scorers, model, aggregator, metadata, log_results, project_name, eval_run_name, override, append, use_judgment, ignore_errors, True, rules)
+        return self.run_evaluation(
+            examples=examples, 
+            scorers=scorers, 
+            model=model, 
+            aggregator=aggregator, 
+            metadata=metadata, 
+            log_results=log_results, 
+            project_name=project_name, 
+            eval_run_name=eval_run_name, 
+            override=override,
+            append=append, 
+            ignore_errors=ignore_errors, 
+            rules=rules
+        )
 
     def run_sequence_evaluation(
         self,
         sequences: List[Sequence],
         model: Union[str, List[str], JudgevalJudge],
+        scorers: List[Union[APIJudgmentScorer, JudgevalScorer]],
         aggregator: Optional[str] = None,
         project_name: str = "default_project",
         eval_run_name: str = "default_eval_sequence",
-        use_judgment: bool = True,
         log_results: bool = True,
+        append: bool = False,
         override: bool = False,
         ignore_errors: bool = True,
         rules: Optional[List[Rule]] = None
     ) -> List[ScoringResult]:
         try:
-            if rules:
-                loaded_rules = []
-                for rule in rules:
-                    try:
-                        processed_conditions = []
-                        for condition in rule.conditions:
-                            # Convert metric if it's a ScorerWrapper
-                            if isinstance(condition.metric, ScorerWrapper):
-                                try:
-                                    condition_copy = condition.model_copy()
-                                    condition_copy.metric = condition.metric.load_implementation(use_judgment=use_judgment)
-                                    processed_conditions.append(condition_copy)
-                                except Exception as e:
-                                    raise ValueError(f"Failed to convert ScorerWrapper to implementation in rule '{rule.name}', condition metric '{condition.metric}': {str(e)}")
-                            else:
-                                processed_conditions.append(condition)
-                        
-                        # Create new rule with processed conditions
-                        new_rule = rule.model_copy()
-                        new_rule.conditions = processed_conditions
-                        loaded_rules.append(new_rule)
-                    except Exception as e:
-                        raise ValueError(f"Failed to process rule '{rule.name}': {str(e)}")
+            def get_all_sequences(root: Sequence) -> List[Sequence]:
+                all_sequences = [root]
+
+                for item in root.items:
+                    if isinstance(item, Sequence):
+                        all_sequences.extend(get_all_sequences(item))
+
+                return all_sequences
+
+            def flatten_sequence_list(sequences: List[Sequence]) -> List[Sequence]:
+                flattened = []
+                for seq in sequences:
+                    flattened.extend(get_all_sequences(seq))
+                return flattened
+            
+            flattened_sequences = flatten_sequence_list(sequences)
+            for sequence in flattened_sequences:
+                sequence.scorers = scorers
                     
             sequence_run = SequenceRun(
                 project_name=project_name,
@@ -134,11 +141,11 @@ class JudgmentClient(metaclass=SingletonMeta):
                 model=model,
                 aggregator=aggregator,
                 log_results=log_results,
+                append=append,
                 judgment_api_key=self.judgment_api_key,
                 organization_id=self.organization_id
             )
-
-            return run_sequence_eval(sequence_run, override, ignore_errors, use_judgment)
+            return run_sequence_eval(sequence_run, override, ignore_errors)
         except ValueError as e:
             raise ValueError(f"Please check your SequenceRun object, one or more fields are invalid: \n{str(e)}")
         except Exception as e:
@@ -147,7 +154,7 @@ class JudgmentClient(metaclass=SingletonMeta):
     def run_evaluation(
         self, 
         examples: Union[List[Example], List[CustomExample]],
-        scorers: List[Union[ScorerWrapper, JudgevalScorer]],
+        scorers: List[Union[APIJudgmentScorer, JudgevalScorer]],
         model: Union[str, List[str], JudgevalJudge],
         aggregator: Optional[str] = None,
         metadata: Optional[Dict[str, Any]] = None,
@@ -156,7 +163,6 @@ class JudgmentClient(metaclass=SingletonMeta):
         eval_run_name: str = "default_eval_run",
         override: bool = False,
         append: bool = False,
-        use_judgment: bool = True,
         ignore_errors: bool = True,
         async_execution: bool = False,
         rules: Optional[List[Rule]] = None
@@ -166,7 +172,7 @@ class JudgmentClient(metaclass=SingletonMeta):
         
         Args:
             examples (Union[List[Example], List[CustomExample]]): The examples to evaluate
-            scorers (List[Union[ScorerWrapper, JudgevalScorer]]): A list of scorers to use for evaluation
+            scorers (List[Union[APIJudgmentScorer, JudgevalScorer]]): A list of scorers to use for evaluation
             model (Union[str, List[str], JudgevalJudge]): The model used as a judge when using LLM as a Judge
             aggregator (Optional[str]): The aggregator to use for evaluation if using Mixture of Judges
             metadata (Optional[Dict[str, Any]]): Additional metadata to include for this evaluation run
@@ -174,7 +180,6 @@ class JudgmentClient(metaclass=SingletonMeta):
             project_name (str): The name of the project the evaluation results belong to
             eval_run_name (str): A name for this evaluation run
             override (bool): Whether to override an existing evaluation run with the same name
-            use_judgment (bool): Whether to use Judgment API for evaluation
             ignore_errors (bool): Whether to ignore errors during evaluation (safely handled)
             rules (Optional[List[Rule]]): Rules to evaluate against scoring results
             
@@ -185,58 +190,21 @@ class JudgmentClient(metaclass=SingletonMeta):
             raise ValueError("Cannot set both override and append to True. Please choose one.")
 
         try:
-            # Load appropriate implementations for all scorers
-            loaded_scorers: List[Union[JudgevalScorer, APIJudgmentScorer]] = []
-            for scorer in scorers:
-                try:
-                    if isinstance(scorer, ScorerWrapper):
-                        loaded_scorers.append(scorer.load_implementation(use_judgment=use_judgment))
-                    else:
-                        loaded_scorers.append(scorer)
-                except Exception as e:
-                    raise ValueError(f"Failed to load implementation for scorer {scorer}: {str(e)}")
-
-            # Prevent using JudgevalScorer with rules - only APIJudgmentScorer allowed with rules
-            if rules and any(isinstance(scorer, JudgevalScorer) for scorer in loaded_scorers):
+            if rules and any(isinstance(scorer, JudgevalScorer) for scorer in scorers):
                 raise ValueError("Cannot use Judgeval scorers (only API scorers) when using rules. Please either remove rules or use only APIJudgmentScorer types.")
 
-            # Convert ScorerWrapper in rules to their implementations
-            loaded_rules = None
-            if rules:
-                loaded_rules = []
-                for rule in rules:
-                    try:
-                        processed_conditions = []
-                        for condition in rule.conditions:
-                            # Convert metric if it's a ScorerWrapper
-                            if isinstance(condition.metric, ScorerWrapper):
-                                try:
-                                    condition_copy = condition.model_copy()
-                                    condition_copy.metric = condition.metric.load_implementation(use_judgment=use_judgment)
-                                    processed_conditions.append(condition_copy)
-                                except Exception as e:
-                                    raise ValueError(f"Failed to convert ScorerWrapper to implementation in rule '{rule.name}', condition metric '{condition.metric}': {str(e)}")
-                            else:
-                                processed_conditions.append(condition)
-                        
-                        # Create new rule with processed conditions
-                        new_rule = rule.model_copy()
-                        new_rule.conditions = processed_conditions
-                        loaded_rules.append(new_rule)
-                    except Exception as e:
-                        raise ValueError(f"Failed to process rule '{rule.name}': {str(e)}")
             eval = EvaluationRun(
                 log_results=log_results,
                 append=append,
                 project_name=project_name,
                 eval_name=eval_run_name,
                 examples=examples,
-                scorers=loaded_scorers,
+                scorers=scorers,
                 model=model,
                 aggregator=aggregator,
                 metadata=metadata,
                 judgment_api_key=self.judgment_api_key,
-                rules=loaded_rules,
+                rules=rules,
                 organization_id=self.organization_id
             )
             return run_eval(eval, override, ignore_errors=ignore_errors, async_execution=async_execution)
@@ -244,98 +212,6 @@ class JudgmentClient(metaclass=SingletonMeta):
             raise ValueError(f"Please check your EvaluationRun object, one or more fields are invalid: \n{str(e)}")
         except Exception as e:
             raise Exception(f"An unexpected error occurred during evaluation: {str(e)}")
-        
-    def evaluate_dataset(
-        self, 
-        dataset: EvalDataset,
-        scorers: List[Union[ScorerWrapper, JudgevalScorer]],
-        model: Union[str, List[str], JudgevalJudge],
-        aggregator: Optional[str] = None,
-        metadata: Optional[Dict[str, Any]] = None,
-        project_name: str = "",
-        eval_run_name: str = "",
-        log_results: bool = True,
-        use_judgment: bool = True,
-        rules: Optional[List[Rule]] = None
-    ) -> List[ScoringResult]:
-        """
-        Executes an evaluation of a `EvalDataset` using one or more `Scorer`s
-        
-        Args:
-            dataset (EvalDataset): The dataset containing examples to evaluate
-            scorers (List[Union[ScorerWrapper, JudgevalScorer]]): A list of scorers to use for evaluation
-            model (Union[str, List[str], JudgevalJudge]): The model used as a judge when using LLM as a Judge
-            aggregator (Optional[str]): The aggregator to use for evaluation if using Mixture of Judges
-            metadata (Optional[Dict[str, Any]]): Additional metadata to include for this evaluation run
-            project_name (str): The name of the project the evaluation results belong to
-            eval_run_name (str): A name for this evaluation run
-            log_results (bool): Whether to log the results to the Judgment API
-            use_judgment (bool): Whether to use Judgment API for evaluation
-            rules (Optional[List[Rule]]): Rules to evaluate against scoring results
-            
-        Returns:
-            List[ScoringResult]: The results of the evaluation
-        """
-        try:
-            # Load appropriate implementations for all scorers
-            loaded_scorers: List[Union[JudgevalScorer, APIJudgmentScorer]] = []
-            for scorer in scorers:
-                try:
-                    if isinstance(scorer, ScorerWrapper):
-                        loaded_scorers.append(scorer.load_implementation(use_judgment=use_judgment))
-                    else:
-                        loaded_scorers.append(scorer)
-                except Exception as e:
-                    raise ValueError(f"Failed to load implementation for scorer {scorer}: {str(e)}")
-
-            # Prevent using JudgevalScorer with rules - only APIJudgmentScorer allowed with rules
-            if rules and any(isinstance(scorer, JudgevalScorer) for scorer in loaded_scorers):
-                raise ValueError("Cannot use Judgeval scorers (only API scorers) when using rules. Please either remove rules or use only APIJudgmentScorer types.")
-
-            # Convert ScorerWrapper in rules to their implementations
-            loaded_rules = None
-            if rules:
-                loaded_rules = []
-                for rule in rules:
-                    try:
-                        processed_conditions = []
-                        for condition in rule.conditions:
-                            # Convert metric if it's a ScorerWrapper
-                            if isinstance(condition.metric, ScorerWrapper):
-                                try:
-                                    condition_copy = condition.model_copy()
-                                    condition_copy.metric = condition.metric.load_implementation(use_judgment=use_judgment)
-                                    processed_conditions.append(condition_copy)
-                                except Exception as e:
-                                    raise ValueError(f"Failed to convert ScorerWrapper to implementation in rule '{rule.name}', condition metric '{condition.metric}': {str(e)}")
-                            else:
-                                processed_conditions.append(condition)
-                        
-                        # Create new rule with processed conditions
-                        new_rule = rule.model_copy()
-                        new_rule.conditions = processed_conditions
-                        loaded_rules.append(new_rule)
-                    except Exception as e:
-                        raise ValueError(f"Failed to process rule '{rule.name}': {str(e)}")
-
-            evaluation_run = EvaluationRun(
-                log_results=log_results,
-                project_name=project_name,
-                eval_name=eval_run_name,
-                examples=dataset.examples,
-                scorers=loaded_scorers,
-                model=model,
-                aggregator=aggregator,
-                metadata=metadata,
-                judgment_api_key=self.judgment_api_key,
-                rules=loaded_rules,
-                organization_id=self.organization_id
-            )
-            return run_eval(evaluation_run)
-        except ValueError as e:
-            raise ValueError(f"Please check your EvaluationRun object, one or more fields are invalid: \n{str(e)}")
-        except Exception as e:
-            raise Exception(f"An unexpected error occurred during evaluation: {str(e)}")
 
     def create_dataset(self) -> EvalDataset:
         return self.eval_dataset_client.create_dataset()
@@ -566,6 +442,8 @@ class JudgmentClient(metaclass=SingletonMeta):
             raise JudgmentAPIError(f"Failed to fetch classifier scorer '{slug}': {response.json().get('detail', '')}")
             
         scorer_config = response.json()
+        created_at = scorer_config.pop("created_at")
+        updated_at = scorer_config.pop("updated_at")
         
         try:
             return ClassifierScorer(**scorer_config)

judgeval/rules.py

@@ -10,7 +10,7 @@ from concurrent.futures import ThreadPoolExecutor
 import time
 import uuid
 
-from judgeval.scorers import APIJudgmentScorer, JudgevalScorer, ScorerWrapper
+from judgeval.scorers import APIJudgmentScorer, JudgevalScorer
 
 class AlertStatus(str, Enum):
     """Status of an alert evaluation."""
@@ -23,22 +23,19 @@ class Condition(BaseModel):
     
     Example:
         {
-            "metric": FaithfulnessScorer(threshold=0.7)  # Must be a scorer object: APIJudgmentScorer, JudgevalScorer, or ScorerWrapper
+            "metric": FaithfulnessScorer(threshold=0.7)  # Must be a scorer object: APIJudgmentScorer, JudgevalScorer
         }
         
     The Condition class uses the scorer's threshold and success function internally.
     """
     model_config = ConfigDict(arbitrary_types_allowed=True)
     
-    metric: Union[APIJudgmentScorer, JudgevalScorer, ScorerWrapper]
+    metric: Union[APIJudgmentScorer, JudgevalScorer]
 
     @property
     def metric_name(self) -> str:
         """Get the name of the metric for lookups in scores dictionary."""
-        if isinstance(self.metric, ScorerWrapper):
-            # Handle ScorerWrapper case specifically
-            return self.metric.scorer.score_type if hasattr(self.metric.scorer, 'score_type') else str(self.metric.scorer)
-        elif hasattr(self.metric, 'score_type'):
+        if hasattr(self.metric, 'score_type'):
             # Handle APIJudgmentScorer and JudgevalScorer which have score_type
             return self.metric.score_type
         elif hasattr(self.metric, '__name__'):

judgeval/run_evaluation.py

@@ -334,9 +334,9 @@ def check_examples(examples: List[Example], scorers: List[APIJudgmentScorer]) ->
                     # Example ID (usually random UUID) does not provide any helpful information for the user but printing the entire example is overdoing it
                     print(f"WARNING: Example {example.example_id} is missing the following parameters: {missing_params} for scorer {scorer.score_type.value}")
 
-def run_sequence_eval(sequence_run: SequenceRun, override: bool = False, ignore_errors: bool = True, async_execution: bool = False) -> List[ScoringResult]:
+def run_sequence_eval(sequence_run: SequenceRun, override: bool = False, ignore_errors: bool = True) -> List[ScoringResult]:
     # Call endpoint to check to see if eval run name exists (if we DON'T want to override and DO want to log results)
-    if not override and sequence_run.log_results:
+    if not override and sequence_run.log_results and not sequence_run.append:
         check_eval_run_name_exists(
             sequence_run.eval_name,
             sequence_run.project_name,

judgeval/scorers/__init__.py

@@ -1,7 +1,7 @@
 from judgeval.scorers.api_scorer import APIJudgmentScorer
 from judgeval.scorers.judgeval_scorer import JudgevalScorer
 from judgeval.scorers.prompt_scorer import PromptScorer, ClassifierScorer
-from judgeval.scorers.judgeval_scorers import (
+from judgeval.scorers.judgeval_scorers.api_scorers import (
     ExecutionOrderScorer,
     JSONCorrectnessScorer,
     SummarizationScorer,
@@ -11,14 +11,15 @@ from judgeval.scorers.judgeval_scorers import (
     ContextualPrecisionScorer,
     ContextualRecallScorer,
     AnswerRelevancyScorer,
-    ScorerWrapper,
     AnswerCorrectnessScorer,
-    Text2SQLScorer,
     ComparisonScorer,
     InstructionAdherenceScorer,
     GroundednessScorer,
     DerailmentScorer,
 )
+from judgeval.scorers.judgeval_scorers.classifiers import (
+    Text2SQLScorer,
+)
 
 __all__ = [
     "APIJudgmentScorer",
@@ -34,7 +35,6 @@ __all__ = [
     "ContextualPrecisionScorer",
     "ContextualRecallScorer",
     "AnswerRelevancyScorer",
-    "ScorerWrapper",
     "AnswerCorrectnessScorer",
     "Text2SQLScorer",
     "ComparisonScorer",