judgeval 0.0.52__py3-none-any.whl → 0.0.54__py3-none-any.whl

judgeval/scorers/score.py

@@ -1,303 +1,72 @@
 """
-Infrastructure for executing evaluations of `Example`s using one or more `JudgevalScorer`s.
+Infrastructure for executing evaluations of `Example`s using one or more `BaseScorer`s.
 """
 
 import asyncio
 import time
 from tqdm.asyncio import tqdm_asyncio
 from typing import List, Union, Optional, Callable
-from rich.progress import Progress, SpinnerColumn, TextColumn
 
 from judgeval.data import (
     Example,
-    CustomExample,
     ScoringResult,
     generate_scoring_result,
     create_scorer_data,
 )
-from judgeval.scorers import JudgevalScorer
-from judgeval.scorers.utils import clone_scorers, scorer_console_msg
-from judgeval.common.exceptions import MissingTestCaseParamsError
-from judgeval.common.logger import example_logging_context, debug, error, warning, info
+from judgeval.scorers import BaseScorer
+from judgeval.scorers.utils import clone_scorers
+from judgeval.common.logger import judgeval_logger
 from judgeval.judges import JudgevalJudge
 
 
 async def safe_a_score_example(
-    scorer: JudgevalScorer,
+    scorer: BaseScorer,
     example: Example,
-    ignore_errors: bool,
-    skip_on_missing_params: bool,
 ):
     """
     Scoring task function when not using a progress indicator!
-    "Safely" scores an `Example` using a `JudgevalScorer` by gracefully handling any exceptions that may occur.
+    "Safely" scores an `Example` using a `BaseScorer` by gracefully handling any exceptions that may occur.
 
     Args:
-        scorer (JudgevalScorer): The `JudgevalScorer` to use for scoring the example.
+        scorer (BaseScorer): The `BaseScorer` to use for scoring the example.
         example (Example): The `Example` to be scored.
 
         ignore_errors (bool): Whether to ignore errors during the evaluation.
         If set to false, any error will be raised and stop the evaluation.
-        If set to true, the error will be stored in the `error` attribute of the `JudgevalScorer` and the `success` attribute will be set to False.
+        If set to true, the error will be stored in the `error` attribute of the `BaseScorer` and the `success` attribute will be set to False.
 
         skip_on_missing_params (bool): Whether to skip the test case if required parameters are missing.
     """
-    debug(f"Starting safe_a_score_example for example {example.example_id}")
     try:
-        await scorer.a_score_example(example, _show_indicator=False)
-        info(f"Successfully scored example {example.example_id}")
-    except MissingTestCaseParamsError as e:
-        if (
-            skip_on_missing_params
-        ):  # Skip the example if the scorer requires parameters that are missing
-            with example_logging_context(example.created_at, example.example_id):
-                warning(
-                    f"Skipping example {example.example_id} due to missing parameters"
-                )
-            scorer.skipped = True
-            return
-        else:
-            if (
-                ignore_errors
-            ):  # Gracefully handle the error, does not stop the evaluation
-                scorer.error = str(e)
-                scorer.success = False
-                with example_logging_context(example.created_at, example.example_id):
-                    warning(
-                        f"Ignoring errors for example {example.example_id}: {str(e)} due to missing parameters"
-                    )
-            else:  # Raise the error and stop the evaluation
-                with example_logging_context(example.created_at, example.example_id):
-                    error(
-                        f"Stopping example {example.example_id}: {str(e)} due to missing parameters"
-                    )
-                raise
-    except TypeError:  # in case a_score_example does not accept _show_indicator
-        try:
-            await scorer.a_score_example(example)
-        except MissingTestCaseParamsError as e:
-            if skip_on_missing_params:
-                scorer.skipped = True
-                with example_logging_context(example.created_at, example.example_id):
-                    warning(
-                        f"Skipping example {example.example_id} due to missing parameters"
-                    )
-                return
-            else:
-                if ignore_errors:
-                    scorer.error = str(e)
-                    scorer.success = False
-                    with example_logging_context(
-                        example.created_at, example.example_id
-                    ):
-                        warning(
-                            f"Ignoring errors for example {example.example_id}: {str(e)} due to missing parameters"
-                        )
-                else:
-                    with example_logging_context(
-                        example.created_at, example.example_id
-                    ):
-                        error(
-                            f"Stopping example {example.example_id}: {str(e)} due to missing parameters"
-                        )
-                    raise
+        scorer.score = await scorer.a_score_example(example)
+        scorer.success = scorer.success_check()
     except Exception as e:
-        if ignore_errors:
-            scorer.error = str(e)
-            scorer.success = False  # Assuming you want to set success to False
-            with example_logging_context(example.created_at, example.example_id):
-                warning(f"Ignoring errors for example {example.example_id}: {str(e)}")
-        else:
-            with example_logging_context(example.created_at, example.example_id):
-                error(f"Stopping example {example.example_id}: {str(e)}")
-            raise
-
-
-async def score_task(
-    task_id: int,
-    progress: Progress,
-    scorer: JudgevalScorer,
-    example: Example,
-    ignore_errors: bool = True,
-    skip_on_missing_params: bool = True,
-):
-    """
-    Task function for asynchronously measuring a given example using a JudgevalScorer.
-
-    Args:
-        task_id (int): The ID of the task being measured.
-        progress (Progress): An instance of the Progress class to track task progress.
-        scorer (JudgevalScorer): An instance of the JudgevalScorer class used to score the example.
-        example (Example): The example to be scored.
-        ignore_errors (bool, optional): Whether to ignore errors during scoring. Defaults to True.
-        skip_on_missing_params (bool, optional): Whether to skip scoring if there are missing parameters. Defaults to True.
-
-    Raises:
-        MissingTestCaseParamsError: If required test case parameters are missing and skip_on_missing_params is False.
-        Exception: If an unexpected error occurs and ignore_errors is False.
-
-    Returns:
-        None
-    """
-    while not progress.finished:
-        start_time = time.perf_counter()
-
-        try:
-            await scorer.a_score_example(example, _show_indicator=False)
-            finish_text = "Completed"
-        except MissingTestCaseParamsError as e:
-            if skip_on_missing_params:
-                scorer.skipped = True
-                with example_logging_context(example.created_at, example.example_id):
-                    debug(
-                        f"Skipping example {example.example_id} due to missing parameters"
-                    )
-                return
-            else:
-                if ignore_errors:
-                    scorer.error = str(e)
-                    scorer.success = False  # Override success
-                    finish_text = "Failed"
-                else:
-                    with example_logging_context(
-                        example.created_at, example.example_id
-                    ):
-                        error(
-                            f"Stopping example {example.example_id}: {str(e)} due to missing parameters"
-                        )
-                    raise
-        except TypeError:
-            try:
-                await scorer.a_score_example(example)
-                finish_text = "Completed"
-            except MissingTestCaseParamsError as e:
-                if skip_on_missing_params:
-                    scorer.skipped = True
-                    with example_logging_context(
-                        example.created_at, example.example_id
-                    ):
-                        debug(
-                            f"Skipping example {example.example_id} due to missing parameters"
-                        )
-                    return
-                else:
-                    if ignore_errors:
-                        scorer.error = str(e)
-                        scorer.success = False  # Override success
-                        finish_text = "Failed"
-                    else:
-                        with example_logging_context(
-                            example.created_at, example.example_id
-                        ):
-                            error(
-                                f"Stopping example {example.example_id}: {str(e)} due to missing parameters"
-                            )
-                        raise
-        except Exception as e:
-            if ignore_errors:
-                scorer.error = str(e)
-                scorer.success = False  # Override success
-                finish_text = "Failed"
-                with example_logging_context(example.created_at, example.example_id):
-                    warning(
-                        f"Ignoring errors for example {example.example_id}: {str(e)}"
-                    )
-            else:
-                with example_logging_context(example.created_at, example.example_id):
-                    error(f"Stopping example {example.example_id}: {str(e)}")
-                raise
-
-        end_time = time.perf_counter()
-        time_taken = format(end_time - start_time, ".2f")
-        progress.update(task_id, advance=100)  # Mark task as complete
-        progress.update(
-            task_id,
-            description=f"{progress.tasks[task_id].description} [rgb(25,227,160)]{finish_text}! ({time_taken}s)",
-        )
-        break
-
-
-async def score_with_indicator(
-    scorers: List[JudgevalScorer],
-    example: Example,
-    ignore_errors: bool,
-    skip_on_missing_params: bool,
-    show_indicator: bool,
-):
-    """
-    Scores an example using a list of JudgevalScorers, optionally displaying a progress indicator.
-
-    Args:
-        scorers (List[JudgevalScorer]): A list of JudgevalScorer objects to evaluate the example.
-        example (Example): The example to be scored.
-        ignore_errors (bool): If True, errors during scoring will be ignored.
-        skip_on_missing_params (bool): If True, scoring will be skipped if required parameters are missing.
-        show_indicator (bool): If True, a progress indicator will be displayed during scoring.
-
-    Returns:
-        None
-
-    Raises:
-        Any exceptions raised by the scoring functions, unless `ignore_errors` is True.
-    """
-    if show_indicator:
-        with Progress(
-            SpinnerColumn(style="rgb(106,0,255)"),
-            TextColumn("[progress.description]{task.description}"),
-            transient=True,
-        ) as progress:
-            tasks = []
-            for scorer in scorers:
-                task_id = progress.add_task(
-                    description=scorer_console_msg(scorer, async_mode=True),
-                    total=100,
-                )  # Add task to progress bar
-                tasks.append(
-                    score_task(
-                        task_id,
-                        progress,
-                        scorer,
-                        example,
-                        ignore_errors,
-                        skip_on_missing_params,
-                    )  # Create and execute task to score the example with a single scorer
-                )
-            await asyncio.gather(*tasks)
-    else:
-        tasks = [
-            safe_a_score_example(scorer, example, ignore_errors, skip_on_missing_params)
-            for scorer in scorers
-        ]
-
-        await asyncio.gather(*tasks)
+        judgeval_logger.error(f"Error during scoring: {str(e)}")
+        scorer.error = str(e)
+        scorer.success = False
+        return
 
 
 async def a_execute_scoring(
-    examples: Union[List[Example], List[CustomExample]],
-    scorers: List[JudgevalScorer],
+    examples: List[Example],
+    scorers: List[BaseScorer],
     model: Optional[Union[str, List[str], JudgevalJudge]] = "gpt-4.1",
-    ignore_errors: bool = True,
-    skip_on_missing_params: bool = True,
-    show_indicator: bool = True,
+    ignore_errors: bool = False,
     throttle_value: int = 0,
     max_concurrent: int = 100,
-    verbose_mode: Optional[bool] = None,
-    _use_bar_indicator: bool = True,
 ) -> List[ScoringResult]:
     """
-    Executes evaluations of `Example`s asynchronously using one or more `JudgevalScorer`s.
-    Each `Example` will be evaluated by all of the `JudgevalScorer`s in the `scorers` list.
+    Executes evaluations of `Example`s asynchronously using one or more `BaseScorer`s.
+    Each `Example` will be evaluated by all of the `BaseScorer`s in the `scorers` list.
 
     Args:
-        examples (Union[List[Example], List[CustomExample]]): A list of `Example` objects to be evaluated.
-        scorers (List[JudgevalScorer]): A list of `JudgevalScorer` objects to evaluate the examples.
+        examples (List[Example]): A list of `Example` objects to be evaluated.
+        scorers (List[BaseScorer]): A list of `BaseScorer` objects to evaluate the examples.
         model (Union[str, List[str], JudgevalJudge]): The model to use for evaluation.
         ignore_errors (bool): Whether to ignore errors during evaluation.
-        skip_on_missing_params (bool): Whether to skip evaluation if parameters are missing.
-        show_indicator (bool): Whether to show a progress indicator.
         throttle_value (int): The amount of time to wait between starting each task.
         max_concurrent (int): The maximum number of concurrent tasks.
-        verbose_mode (Optional[bool]): If set, enables verbose mode for scorers.
+
         _use_bar_indicator (bool): Whether to use a progress bar indicator.
 
     Returns:
@@ -311,69 +80,31 @@ async def a_execute_scoring(
             try:
                 return await func(*args, **kwargs)
             except Exception as e:
-                print(f"Error executing function: {e}")
+                judgeval_logger.error(f"Error executing function: {e}")
                 if kwargs.get("ignore_errors", False):
                     # Simply return None when ignoring errors, as expected by the test
                     return None
                 # If we're not ignoring errors, propagate the exception
                 raise
 
-    if verbose_mode is not None:
-        for scorer in scorers:
-            scorer.verbose_mode = verbose_mode
-
     # Add model to scorers
     for scorer in scorers:
         scorer._add_model(model)
 
     scoring_results: List[ScoringResult] = [None for _ in examples]
     tasks = []
-    cloned_scorers: List[JudgevalScorer]
-
-    if show_indicator and _use_bar_indicator:
-        with tqdm_asyncio(
-            desc=f"Evaluating {len(examples)} example(s) in parallel",
-            unit="Example",
-            total=len(examples),
-            bar_format="{desc}: |{bar}|{percentage:3.0f}% ({n_fmt}/{total_fmt}) [Time Taken: {elapsed}, {rate_fmt}{postfix}]",
-        ) as pbar:
-            for i, ex in enumerate(examples):
-                with example_logging_context(ex.created_at, ex.example_id):
-                    debug(f"Starting scoring for example {ex.example_id}")
-                    debug(f"Input: {ex.input}")
-                    debug(f"Using {len(scorers)} scorers")
-                    for scorer in scorers:
-                        debug(f"Using scorer: {type(scorer).__name__}")
-                        if hasattr(scorer, "threshold"):
-                            debug(f"Scorer threshold: {scorer.threshold}")
-                        if hasattr(scorer, "model"):
-                            debug(f"Scorer model: {type(scorer.model).__name__}")
-                if isinstance(ex, Example) or isinstance(ex, CustomExample):
-                    if len(scorers) == 0:
-                        pbar.update(1)
-                        continue
-
-                    cloned_scorers = clone_scorers(scorers)
-                    task = execute_with_semaphore(
-                        func=a_eval_examples_helper,
-                        scorers=cloned_scorers,
-                        example=ex,
-                        scoring_results=scoring_results,
-                        score_index=i,
-                        ignore_errors=ignore_errors,
-                        skip_on_missing_params=skip_on_missing_params,
-                        show_indicator=show_indicator,
-                        _use_bar_indicator=_use_bar_indicator,
-                        pbar=pbar,
-                    )
-                    tasks.append(asyncio.create_task(task))
-
-                await asyncio.sleep(throttle_value)
-            await asyncio.gather(*tasks)
-    else:
+    cloned_scorers: List[BaseScorer]
+
+    with tqdm_asyncio(
+        desc=f"Evaluating {len(examples)} example(s) in parallel",
+        unit="Example",
+        total=len(examples),
+        bar_format="{desc}: |{bar}|{percentage:3.0f}% ({n_fmt}/{total_fmt}) [Time Taken: {elapsed}, {rate_fmt}{postfix}]",
+    ) as pbar:
         for i, ex in enumerate(examples):
-            if isinstance(ex, Example) or isinstance(ex, CustomExample):
+            if isinstance(ex, Example):
                 if len(scorers) == 0:
+                    pbar.update(1)
                     continue
 
                 cloned_scorers = clone_scorers(scorers)
@@ -384,11 +115,9 @@ async def a_execute_scoring(
                     scoring_results=scoring_results,
                     score_index=i,
                     ignore_errors=ignore_errors,
-                    skip_on_missing_params=skip_on_missing_params,
-                    _use_bar_indicator=_use_bar_indicator,
-                    show_indicator=show_indicator,
+                    pbar=pbar,
                 )
-                tasks.append(asyncio.create_task((task)))
+                tasks.append(asyncio.create_task(task))
 
             await asyncio.sleep(throttle_value)
         await asyncio.gather(*tasks)
@@ -396,48 +125,33 @@ async def a_execute_scoring(
 
 
 async def a_eval_examples_helper(
-    scorers: List[JudgevalScorer],
-    example: Union[Example, CustomExample],
+    scorers: List[BaseScorer],
+    example: Example,
     scoring_results: List[ScoringResult],
     score_index: int,
     ignore_errors: bool,
-    skip_on_missing_params: bool,
-    show_indicator: bool,
-    _use_bar_indicator: bool,
     pbar: Optional[tqdm_asyncio] = None,
 ) -> None:
     """
     Evaluate a single example asynchronously using a list of scorers.
 
     Args:
-        scorers (List[JudgevalScorer]): List of JudgevalScorer objects to evaluate the example.
+        scorers (List[BaseScorer]): List of BaseScorer objects to evaluate the example.
         example (Example): The example to be evaluated.
         scoring_results (List[ScoringResult]): List to store the scoring results.
         score_index (int): Index at which the result should be stored in scoring_results.
         ignore_errors (bool): Flag to indicate whether to ignore errors during scoring.
-        skip_on_missing_params (bool): Flag to indicate whether to skip scoring if parameters are missing.
-        show_indicator (bool): Flag to indicate whether to show a progress indicator.
-        _use_bar_indicator (bool): Flag to indicate whether to use a bar indicator for progress.
         pbar (Optional[tqdm_asyncio]): Optional progress bar for tracking progress.
     Returns:
         None
     """
 
-    show_metrics_indicator = show_indicator and not _use_bar_indicator
-
-    for scorer in scorers:
-        scorer.skipped = False
-        scorer.error = None  # Reset scorer error
-
     # scoring the Example
     scoring_start_time = time.perf_counter()
-    await score_with_indicator(
-        scorers=scorers,
-        example=example,
-        skip_on_missing_params=skip_on_missing_params,
-        ignore_errors=ignore_errors,
-        show_indicator=show_metrics_indicator,
-    )  # execute the scoring functions of each scorer on the example
+
+    tasks = [safe_a_score_example(scorer, example) for scorer in scorers]
+
+    await asyncio.gather(*tasks)
 
     # Now that all the scoring functions of each scorer have executed, we collect
     # the results and update the ScoringResult with the scorer data
@@ -450,8 +164,9 @@ async def a_eval_examples_helper(
         scorer_data = create_scorer_data(
             scorer
         )  # Fetch scorer data from completed scorer evaluation
-        success = success and scorer_data.success
-        scorer_data_list.append(scorer_data)
+        for s in scorer_data:
+            success = success and s.success
+        scorer_data_list.extend(scorer_data)
 
     scoring_end_time = time.perf_counter()
     run_duration = scoring_end_time - scoring_start_time

judgeval/scorers/utils.py

@@ -6,19 +6,15 @@ import asyncio
 import nest_asyncio
 import inspect
 import json
-import sys
 import re
-from contextlib import contextmanager
-from rich.progress import Progress, SpinnerColumn, TextColumn
-from rich.console import Console
 from typing import List, Optional
 
-from judgeval.scorers import JudgevalScorer
+from judgeval.scorers import BaseScorer
 from judgeval.data import Example, ExampleParams
 from judgeval.scorers.exceptions import MissingExampleParamsError
 
 
-def clone_scorers(scorers: List[JudgevalScorer]) -> List[JudgevalScorer]:
+def clone_scorers(scorers: List[BaseScorer]) -> List[BaseScorer]:
     """
     Creates duplicates of the scorers passed as argument.
     """
@@ -32,60 +28,14 @@ def clone_scorers(scorers: List[JudgevalScorer]) -> List[JudgevalScorer]:
         valid_args = {key: args[key] for key in valid_params if key in args}
 
         cloned_scorer = scorer_class(**valid_args)
-        # kinda hacky, but in case the class inheriting from JudgevalScorer doesn't have `model` in its __init__,
+        # kinda hacky, but in case the class inheriting from BaseScorer doesn't have `model` in its __init__,
         # we need to explicitly include it here so that we can add the judge model to the cloned scorer
         cloned_scorer._add_model(model=args.get("model"))
         cloned_scorers.append(cloned_scorer)
     return cloned_scorers
 
 
-def scorer_console_msg(
-    scorer: JudgevalScorer,
-    async_mode: Optional[bool] = None,
-):
-    """
-    Renders a message to be displayed to console when a scorer is being executed.
-    """
-    if async_mode is None:
-        run_async = scorer.async_mode
-    else:
-        run_async = async_mode
-
-    return f"🔨 Executing Judgment's [rgb(106,0,255)]{scorer.__name__} Scorer[/rgb(106,0,255)]! \
-        [rgb(55,65,81)](using {scorer.evaluation_model}, async_mode={run_async})...[/rgb(55,65,81)]"
-
-
-@contextmanager
-def scorer_progress_meter(
-    scorer: JudgevalScorer,
-    async_mode: Optional[bool] = None,
-    display_meter: bool = True,
-    total: int = 100,
-    transient: bool = True,
-):
-    """
-    Context manager to display a progress indicator (spinner) while a scorer is being run.
-    """
-    console = Console(file=sys.stderr)
-    if display_meter:
-        with Progress(
-            SpinnerColumn(style="rgb(106,0,255)"),
-            TextColumn("[progress.description]{task.description}"),
-            console=console,
-            transient=transient,
-        ) as progress:
-            progress.add_task(
-                description=scorer_console_msg(scorer, async_mode),
-                total=total,
-            )
-            yield
-    else:
-        yield
-
-
-def parse_response_json(
-    llm_response: str, scorer: Optional[JudgevalScorer] = None
-) -> dict:
+def parse_response_json(llm_response: str, scorer: Optional[BaseScorer] = None) -> dict:
     """
     Extracts JSON output from an LLM response and returns it as a dictionary.
 
@@ -93,7 +43,7 @@ def parse_response_json(
 
     Args:
         llm_response (str): The response from an LLM.
-        scorer (JudgevalScorer, optional): The scorer object to forward errors to (if any).
+        scorer (BaseScorer, optional): The scorer object to forward errors to (if any).
     """
     start = llm_response.find("{")  # opening bracket
     end = llm_response.rfind("}") + 1  # closing bracket
@@ -120,38 +70,6 @@ def parse_response_json(
         raise Exception(f"An unexpected error occurred: {str(e)}")
 
 
-def print_verbose_logs(metric: str, logs: str):
-    print("*" * 50)
-    print(f"{metric} Verbose Logs")
-    print("*" * 50)
-    print("")
-    print(logs)
-    print("")
-    print("=" * 70)
-
-
-def create_verbose_logs(metric: JudgevalScorer, steps: List[str]) -> str:
-    """
-    Creates verbose logs for a scorer object.
-
-    Args:
-        metric (JudgevalScorer): The scorer object.
-        steps (List[str]): The steps to be included in the verbose logs.
-
-    Returns:
-        str: The verbose logs (Concatenated steps).
-    """
-
-    verbose_logs = ""
-    for i in range(len(steps) - 1):
-        verbose_logs += steps[i]
-        if i < len(steps) - 2:  # don't add new line for penultimate step
-            verbose_logs += " \n \n"
-    if metric.verbose_mode:
-        print_verbose_logs(metric.__name__, verbose_logs + f"\n \n{steps[-1]}")
-    return verbose_logs
-
-
 def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
     """
     Get or create an asyncio event loop.
@@ -186,7 +104,7 @@ def get_or_create_event_loop() -> asyncio.AbstractEventLoop:
 def check_example_params(
     example: Example,
     example_params: List[ExampleParams],
-    scorer: JudgevalScorer,
+    scorer: BaseScorer,
 ):
     if isinstance(example, Example) is False:
         error_str = f"in check_example_params(): Expected example to be of type 'Example', but got {type(example)}"

judgeval/utils/file_utils.py

@@ -1,16 +1,15 @@
 import yaml
 from typing import List
-from judgeval.common.logger import debug, info, error
+from judgeval.common.logger import judgeval_logger
 
 from judgeval.data import Example
 
 
 def get_examples_from_yaml(file_path: str) -> List[Example] | None:
-    debug(f"Loading dataset from YAML file: {file_path}")
     """
     Adds examples from a YAML file.
 
-    The format of the YAML file is expected to be a dictionary with one key: "examples". 
+    The format of the YAML file is expected to be a dictionary with one key: "examples".
     The value of the key is a list of dictionaries, where each dictionary represents an example.
 
     The YAML file is expected to have the following format:
@@ -42,12 +41,11 @@ def get_examples_from_yaml(file_path: str) -> List[Example] | None:
                 raise ValueError("The YAML file is empty.")
             examples = payload.get("examples", [])
     except FileNotFoundError:
-        error(f"YAML file not found: {file_path}")
+        judgeval_logger.error(f"YAML file not found: {file_path}")
         raise FileNotFoundError(f"The file {file_path} was not found.")
     except yaml.YAMLError:
-        error(f"Invalid YAML file: {file_path}")
+        judgeval_logger.error(f"Invalid YAML file: {file_path}")
         raise ValueError(f"The file {file_path} is not a valid YAML file.")
 
-    info(f"Added {len(examples)} examples from YAML")
     new_examples = [Example(**e) for e in examples]
     return new_examples

judgeval/version_check.py

@@ -1,6 +1,7 @@
 import importlib.metadata
 from judgeval.utils.requests import requests
 import threading
+from judgeval.common.logger import judgeval_logger
 
 
 def check_latest_version(package_name: str = "judgeval"):
@@ -13,8 +14,8 @@ def check_latest_version(package_name: str = "judgeval"):
             latest_version = response.json()["info"]["version"]
 
             if current_version != latest_version:
-                print(
-                    f"\033[93mUPDATE AVAILABLE:\033[0m You are using '{package_name}=={current_version}', "
+                judgeval_logger.warning(
+                    f"UPDATE AVAILABLE: You are using '{package_name}=={current_version}', "
                     f"but the latest version is '{latest_version}'. While this version is still supported, "
                     f"we recommend upgrading to avoid potential issues or missing features: "
                     f"`pip install --upgrade {package_name}`"