judgeval 0.0.1__py3-none-any.whl

judgeval/scorers/score.py

@@ -0,0 +1,427 @@
+"""
+Infrastructure for executing evaluations of `Example`s using one or more `CustomScorer`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, 
+    ScoringResult,
+    generate_scoring_result,
+    create_process_example,
+    create_scorer_data,
+)
+from judgeval.scorers import CustomScorer
+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.judges import judgevalJudge
+
+async def safe_a_score_example(
+    scorer: CustomScorer,
+    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 `CustomScorer` by gracefully handling any exceptions that may occur.
+
+    Args:
+        scorer (CustomScorer): The `CustomScorer` 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 `CustomScorer` 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.timestamp, 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.timestamp, 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.timestamp, 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.timestamp, 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.timestamp, example.example_id):
+                        warning(f"Ignoring errors for example {example.example_id}: {str(e)} due to missing parameters")
+                else:
+                    with example_logging_context(example.timestamp, 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  # Assuming you want to set success to False
+            with example_logging_context(example.timestamp, example.example_id):
+                warning(f"Ignoring errors for example {example.example_id}: {str(e)}")
+        else:
+            with example_logging_context(example.timestamp, example.example_id):
+                error(f"Stopping example {example.example_id}: {str(e)}")
+            raise
+
+
+async def score_task(
+    task_id: int,
+    progress: Progress,
+    scorer: CustomScorer,
+    example: Example,
+    ignore_errors: bool = True,
+    skip_on_missing_params: bool = True,
+):
+    """
+    Task function for asynchronously measuring a given example using a custom scorer.
+
+    Args:
+        task_id (int): The ID of the task being measured.
+        progress (Progress): An instance of the Progress class to track task progress.
+        scorer (CustomScorer): An instance of the CustomScorer 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.timestamp, 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.timestamp, 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.timestamp, 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.timestamp, 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.timestamp, example.example_id):
+                    warning(f"Ignoring errors for example {example.example_id}: {str(e)}")
+            else:
+                with example_logging_context(example.timestamp, 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[CustomScorer],
+    example: Example,
+    ignore_errors: bool,
+    skip_on_missing_params: bool,
+    show_indicator: bool,
+):
+    """
+    Scores an example using a list of custom scorers, optionally displaying a progress indicator.
+
+    Args:
+        scorers (List[CustomScorer]): A list of custom scorer 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)
+
+
+async def a_execute_scoring(
+    examples: List[Example],
+    scorers: List[CustomScorer],
+    model: Optional[Union[str, List[str], judgevalJudge]] = None,
+    ignore_errors: bool = True,
+    skip_on_missing_params: bool = True,
+    show_indicator: bool = True,
+    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 `CustomScorer`s.
+    Each `Example` will be evaluated by all of the `CustomScorer`s in the `scorers` list.
+
+        examples (List[Example]): A list of `Example` objects to be evaluated.
+        scorers (List[CustomScorer]): A list of `CustomScorer` 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:
+        List[ScoringResult]: A list of `ScoringResult` objects containing the evaluation results.
+    """
+    semaphore = asyncio.Semaphore(max_concurrent)
+
+    async def execute_with_semaphore(func: Callable, *args, **kwargs):
+        try:
+            async with semaphore:
+                return await func(*args, **kwargs)
+        except Exception as e:
+            error(f"Error executing function: {e}")
+            if kwargs.get('ignore_errors', False):
+                # Return None when ignoring errors
+                return None
+            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 = []
+
+    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.timestamp, 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):
+                    if len(scorers) == 0:
+                        pbar.update(1)
+                        continue
+
+                    cloned_scorers: List[CustomScorer] = 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:
+        for i, ex in enumerate(examples):
+            if isinstance(ex, Example):
+                if len(scorers) == 0:
+                    continue
+
+                cloned_scorers: List[CustomScorer] = 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,
+                    _use_bar_indicator=_use_bar_indicator,
+                    show_indicator=show_indicator,
+                )
+                tasks.append(asyncio.create_task((task)))
+
+            await asyncio.sleep(throttle_value)
+        await asyncio.gather(*tasks)
+    return scoring_results
+
+
+async def a_eval_examples_helper(
+    scorers: List[CustomScorer],
+    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[CustomScorer]): List of CustomScorer 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
+    process_example = create_process_example(example)  # Creates process example to track progress
+    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
+
+    # Now that all the scoring functions of each scorer have executed, we collect 
+    # the results and update the process example with the scorer data
+    for scorer in scorers:
+        # At this point, the scorer has been executed and already contains data.
+        if getattr(scorer, 'skipped', False):
+            continue
+        
+        scorer_data = create_scorer_data(scorer)  # Fetch scorer data from completed scorer evaluation
+        process_example.update_scorer_data(scorer_data)  # Update process example with the same scorer data
+          
+    test_end_time = time.perf_counter()
+    run_duration = test_end_time - scoring_start_time
+    
+    process_example.update_run_duration(run_duration)   # Update process example with execution time duration
+    scoring_results[score_index] = generate_scoring_result(process_example)  # Converts the outcomes of the executed test to a ScoringResult and saves it
+
+    if pbar is not None:
+        pbar.update(1)

judgeval/scorers/utils.py

@@ -0,0 +1,175 @@
+"""
+Util functions for Scorer objects
+"""
+
+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, Any
+
+from judgeval.scorers import CustomScorer
+
+
+def clone_scorers(scorers: List[CustomScorer]) -> List[CustomScorer]:
+    """
+    Creates duplicates of the scorers passed as argument.
+    """
+    cloned_scorers = []
+    for s in scorers:
+        scorer_class = type(s)
+        args = vars(s)
+
+        signature = inspect.signature(scorer_class.__init__)
+        valid_params = signature.parameters.keys()
+        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 CustomScorer 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: CustomScorer,
+    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: CustomScorer,
+    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[CustomScorer] = None) -> dict:
+    """
+    Extracts JSON output from an LLM response and returns it as a dictionary.
+
+    If the JSON is invalid, the error is forwarded to the `scorer`, if provided.
+
+    Args:
+        llm_response (str): The response from an LLM.
+        scorer (CustomScorer, optional): The scorer object to forward errors to (if any).
+    """
+    start = llm_response.find("{")  # opening bracket
+    end = llm_response.rfind("}") + 1  # closing bracket
+
+    if end == 0 and start != -1:  # add the closing bracket if it's missing
+        llm_response = llm_response + "}"
+        end = len(llm_response)
+
+    json_str = llm_response[start:end] if start != -1 and end != 0 else ""  # extract the JSON string
+    json_str = re.sub(r",\s*([\]}])", r"\1", json_str)  # Remove trailing comma if present
+
+    try:
+        return json.loads(json_str)
+    except json.JSONDecodeError:
+        error_str = "Evaluation LLM outputted an invalid JSON. Please use a stronger evaluation model."
+        if scorer is not None:
+            scorer.error = error_str
+        raise ValueError(error_str)
+    except Exception as e:
+        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: CustomScorer, steps: List[str]) -> str:
+    """
+    Creates verbose logs for a scorer object.
+
+    Args:
+        metric (CustomScorer): 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.
+
+    This function attempts to retrieve the current event loop using `asyncio.get_event_loop()`.
+    If the event loop is already running, it applies the `nest_asyncio` patch to allow nested
+    asynchronous execution. If the event loop is closed or not found, it creates a new event loop
+    and sets it as the current event loop.
+
+    Returns:
+        asyncio.AbstractEventLoop: The current or newly created event loop.
+    
+    Raises:
+        RuntimeError: If the event loop is closed.
+    """
+    try:
+        loop = asyncio.get_event_loop()
+        if loop.is_running():
+            print(
+                "Event loop is already running. Applying nest_asyncio patch to allow async execution..."
+            )
+            nest_asyncio.apply()
+
+        if loop.is_closed():
+            raise RuntimeError
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    return loop

judgeval-0.0.1.dist-info/METADATA

@@ -0,0 +1,40 @@
+Metadata-Version: 2.4
+Name: judgeval
+Version: 0.0.1
+Summary: Judgeval Package
+Project-URL: Homepage, https://github.com/JudgmentLabs/judgeval
+Project-URL: Issues, https://github.com/JudgmentLabs/judgeval/issues
+Author-email: Andrew Li <andrew@judgmentlabs.ai>, Alex Shan <alex@judgmentlabs.ai>, Joseph Camyre <joseph@judgmentlabs.ai>
+License-Expression: Apache-2.0
+License-File: LICENSE.md
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: anthropic>=0.43.1
+Requires-Dist: deepeval>=2.1.8
+Requires-Dist: fastapi>=0.115.6
+Requires-Dist: langfuse==2.50.3
+Requires-Dist: litellm>=1.48.10
+Requires-Dist: openai>=1.47.1
+Requires-Dist: pandas>=2.2.3
+Requires-Dist: patronus>=0.0.17
+Requires-Dist: python-dotenv==1.0.1
+Requires-Dist: requests>=2.32.3
+Requires-Dist: supabase>=2.11.0
+Requires-Dist: together>=1.3.11
+Requires-Dist: uvicorn>=0.34.0
+Provides-Extra: dev
+Requires-Dist: pytest-asyncio>=0.25.0; extra == 'dev'
+Requires-Dist: pytest-mock>=3.14.0; extra == 'dev'
+Requires-Dist: pytest>=8.3.4; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# judgeval
+
+
+TODOS
+
+1. public interface for Example and Measurement objects
+2. call to backend
+3. datasets and logging
+4. exporting to platform

judgeval-0.0.1.dist-info/RECORD

@@ -0,0 +1,46 @@
+judgeval/__init__.py,sha256=ZLaxoUwq-b86Ugj3543Z1v4Q0D8ukHRpxV7LcZrcOZs,1875
+judgeval/clients.py,sha256=boWW-nA7Yqt2zBflMxl2NpdUIFSSKebv3rJiG50K1s4,594
+judgeval/constants.py,sha256=5OiK-r6DLD2utExYaFnvfpSYxrXbVYzRDxSO6lVNE6k,1919
+judgeval/evaluation_run.py,sha256=Z1Y9_w7xWK6sjH4sXupPYNl6-BTlJu4kYF8KJcB3MF8,5763
+judgeval/judgment_client.py,sha256=QBEgWkkNvrHpkmhPIS0YhsDYDWYxGenQSjopz5QSsas,9574
+judgeval/run_evaluation.py,sha256=LzEoWhtsXE_HwMRgmzkkMKfbqw2h1sh7WjChy5HOUfQ,16252
+judgeval/common/__init__.py,sha256=7d24BRxtncpMj3AAJCj8RS7TqgjXmW777HVZH6-3sBs,289
+judgeval/common/exceptions.py,sha256=U-TxHLn7oVMezsMuoYouNDb2XuS8RCggfntYf5_6u4E,565
+judgeval/common/logger.py,sha256=QXN3UMymmKu2iMEMEgATLBnMDjGr_pE2iOSEFoICgg8,6092
+judgeval/common/tracer.py,sha256=7t--uQMcxVLl2Hqemem_EUy90lAhbvrHss5_ujFlI8Y,22310
+judgeval/common/utils.py,sha256=3WRyyX0tvnnj_VAVlEdtZrfzyWj6zfX04xdpCtE1m5Y,33736
+judgeval/data/__init__.py,sha256=-Js66xgj0g7wtUk8Q2CIK9ynGL8pGlVRubVlfO7OgX4,438
+judgeval/data/api_example.py,sha256=vwWFbI6eJr5VgURCRbuSiMtEXLUbTCih_BcaqEBy-pg,4108
+judgeval/data/example.py,sha256=lymGZ3jG818-r2vyFunt6OLFrhESOyJnbhao_ljTjlA,2471
+judgeval/data/result.py,sha256=CVp_mZrBbKjIH9rPB6rg7T2jY1jUy7JVyI7_kUbRC7w,3490
+judgeval/data/scorer_data.py,sha256=H7s-yEEUdWlR4mRgy5JkLOQXNkn2YLu9wkZwcAlh6QQ,3276
+judgeval/data/datasets/__init__.py,sha256=Xh6TSsCcEsJeYjjubfeGa3WU8YQfuwKXH3jR9EeDFgg,171
+judgeval/data/datasets/dataset.py,sha256=9GGspdKDhMw2dJAS7ZvOZHSoNGwMzCtgnFYDe6y4yog,16484
+judgeval/data/datasets/ground_truth.py,sha256=OTBs3VZe-Wp0vEXEsq14GPZHYtpWT16bhGQTycIvkKc,2057
+judgeval/data/datasets/utils.py,sha256=lQxyl7mevct7JcDSyIrU_8QOzT-EYPWEvoUiAeOdeek,2502
+judgeval/judges/__init__.py,sha256=4DuGgrJAec2GavvU3wgQ5alOgi9q0GzFzrtGBJxO2Cs,339
+judgeval/judges/base_judge.py,sha256=PUj7tITRjWjk6Www5Qcrt6Z3YNr9ix69aqjFs-dMQjA,1000
+judgeval/judges/litellm_judge.py,sha256=xW0Ld7dumercO7ej8aTNDRow1lsVpgaDENTFq1WkiU0,2424
+judgeval/judges/mixture_of_judges.py,sha256=WELi58rKtJuamkQWbhcqMn7AfRj1qX1LcDyOE0B3FZc,15532
+judgeval/judges/together_judge.py,sha256=eISgPcnAS71Di9FL9z0AfvBK9nb57a_muCUzboxv7gQ,2275
+judgeval/judges/utils.py,sha256=Aj1XrK0WXeJStsDLB-Cx757fRuJCWmJRMVD3ngoa9Oo,2110
+judgeval/scorers/__init__.py,sha256=U9uiW7y707g8ibjc2ZCBlm61ijziJMM2xQSHDV7FerQ,845
+judgeval/scorers/base_scorer.py,sha256=_n-w7b_PD_-DoW1gr2c3CtrT5dvLehRjDYLQDF-81LM,1786
+judgeval/scorers/custom_scorer.py,sha256=SrkrtIqs9yaqvUZG3ilXIGm6S78uX1YOygqWpl4xXfw,6039
+judgeval/scorers/prompt_scorer.py,sha256=-YVG9k03q85YnyLVR2lsC-RmxUM4Q5ynHdUECi63iCk,17813
+judgeval/scorers/score.py,sha256=zvS5xF3qlUYS716TeyNPikYZWXrUTKirAr1uqXO-P14,18589
+judgeval/scorers/utils.py,sha256=RCpHc7EQF_LnujsZ0KV-kTYvmHpVS1psJqIgZOuqOgA,5613
+judgeval/scorers/judgeval_scorers/__init__.py,sha256=YcpuD8qFuhyPEwFiKBgqxQpjqo43I3ODHH3yJnR75B4,1044
+judgeval/scorers/judgeval_scorers/answer_relevancy.py,sha256=xpS-WclR8SV7HDmpUPp3P55Ybfcm6Gj1kfr2hJG_-cg,452
+judgeval/scorers/judgeval_scorers/contextual_precision.py,sha256=3nFcrfNTGmHnmfM3UxlLLzAK0qz9VKkEMjmDa6j7thI,468
+judgeval/scorers/judgeval_scorers/contextual_recall.py,sha256=O8bnQxJJGmIjSUMgR7_8VG2qlSP-7OJiHauCxHGkcgw,456
+judgeval/scorers/judgeval_scorers/contextual_relevancy.py,sha256=rrUmyWZdKrONjm_seRvFltS5YM9QiiO6o5-DVlNTYPE,569
+judgeval/scorers/judgeval_scorers/faithfulness.py,sha256=CHqB-_KMnRw24jg0am0SpHuYMx3u3Gy5YtQNAPNXZ_I,437
+judgeval/scorers/judgeval_scorers/hallucination.py,sha256=7omZbrQWTgZ4Fnw8wQSgvsmuj-g9bm74AP1xZM_mDhs,441
+judgeval/scorers/judgeval_scorers/json_correctness.py,sha256=guGR5lgTtwG8qqVI7dFt6hHGEYM98XzZhqPzh69Ogqg,866
+judgeval/scorers/judgeval_scorers/summarization.py,sha256=OwF-sNtRg2HN6FoRCCYTow_SNfS9Rcxzb7ZDBTEld7k,445
+judgeval/scorers/judgeval_scorers/tool_correctness.py,sha256=7nAXrDKfPkeMzRLiNTevbUV5pjRXPTM2dbkfGRgSJ-s,452
+judgeval-0.0.1.dist-info/METADATA,sha256=4TZnY-nRVAgCKd9e-Ok_qr-B25sB39HYMvl-THUgHzg,1278
+judgeval-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+judgeval-0.0.1.dist-info/licenses/LICENSE.md,sha256=tKmCg7k5QOmxPK19XMfzim04QiQJPmgIm0pAn55IJwk,11352
+judgeval-0.0.1.dist-info/RECORD,,