evalproof 0.2.0__py3-none-any.whl

evalproof/systems.py

@@ -0,0 +1,154 @@
+"""Systems under test: an LLM prompt, a Python function, or an HTTP endpoint.
+
+A system failure is recorded on the case, not raised: one timeout should not throw
+away an hour of judging. Errored cases score as failures and are listed in reports.
+"""
+
+from __future__ import annotations
+
+import importlib
+import string
+import sys
+import time
+from collections.abc import Callable
+from typing import Any, Protocol
+
+import httpx
+
+from evalproof.cache import CachedProvider, ResponseCache
+from evalproof.config import ConfigError, TargetConfig
+from evalproof.models import Case, SystemOutput
+from evalproof.providers import Message, Provider, ProviderError, make_provider, with_retries
+
+
+class System(Protocol):
+    name: str
+
+    def run(self, case: Case) -> SystemOutput: ...
+
+
+def render(template: str, variables: dict[str, Any]) -> str:
+    """``str.format`` with a clear error naming the missing field."""
+    missing = [
+        field
+        for _, field, _, _ in string.Formatter().parse(template)
+        if field and field.split(".")[0].split("[")[0] not in variables
+    ]
+    if missing:
+        raise ConfigError(f"prompt template references unknown fields: {sorted(set(missing))}")
+    return template.format_map(variables)
+
+
+class LLMSystem:
+    def __init__(self, cfg: TargetConfig, provider: Provider) -> None:
+        self.cfg = cfg
+        self.provider = provider
+        self.name = cfg.label or cfg.target
+
+    def messages(self, case: Case) -> list[Message]:
+        msgs: list[Message] = []
+        if self.cfg.system_prompt:
+            msgs.append(Message(role="system", content=self.cfg.system_prompt))
+        msgs.append(
+            Message(role="user", content=render(self.cfg.prompt_template, case.render_vars()))
+        )
+        return msgs
+
+    def run(self, case: Case) -> SystemOutput:
+        try:
+            resp = self.provider.chat(self.messages(case), self.cfg.params)
+        except ProviderError as exc:
+            return SystemOutput(output="", error=str(exc))
+        return SystemOutput(
+            output=resp.text,
+            latency_ms=resp.latency_ms,
+            tokens_in=resp.tokens_in,
+            tokens_out=resp.tokens_out,
+            cost_usd=self.cfg.pricing.cost(resp.tokens_in, resp.tokens_out),
+            cached=resp.cached,
+        )
+
+
+def _coerce(result: Any) -> tuple[str, list[str]]:
+    if isinstance(result, str):
+        return result, []
+    if isinstance(result, dict) and "output" in result:
+        return str(result["output"]), [str(x) for x in result.get("retrieved") or []]
+    raise TypeError("a system must return a string or a dict with an 'output' key")
+
+
+class PythonSystem:
+    """``python:package.module:function`` — the function receives the case input.
+
+    ``search_path`` (the suite's directory) is put on ``sys.path`` so a suite can ship
+    its system next to it and still run from any working directory.
+    """
+
+    def __init__(self, spec: str, search_path: str | None = None) -> None:
+        self.name = spec
+        if search_path and search_path not in sys.path:
+            sys.path.insert(0, search_path)
+        try:
+            _, module_name, func_name = spec.split(":", 2)
+        except ValueError as exc:
+            raise ConfigError(
+                f"python target must be 'python:<module>:<function>', got {spec!r}"
+            ) from exc
+        module = importlib.import_module(module_name)
+        func = getattr(module, func_name, None)
+        if not callable(func):
+            raise ConfigError(f"{module_name}.{func_name} is not callable")
+        self.func: Callable[[Any], Any] = func
+
+    def run(self, case: Case) -> SystemOutput:
+        start = time.perf_counter()
+        try:
+            output, retrieved = _coerce(self.func(case.input))
+        except Exception as exc:
+            return SystemOutput(output="", error=f"{type(exc).__name__}: {exc}")
+        return SystemOutput(
+            output=output, retrieved=retrieved, latency_ms=(time.perf_counter() - start) * 1000
+        )
+
+
+class HttpSystem:
+    """POSTs ``{"id", "input"}``; expects JSON ``{"output", "retrieved"?}`` or plain text."""
+
+    def __init__(self, cfg: TargetConfig, client: httpx.Client | None = None) -> None:
+        self.cfg = cfg
+        self.name = cfg.label or cfg.target
+        self._client = client or httpx.Client(timeout=cfg.timeout_s)
+
+    def run(self, case: Case) -> SystemOutput:
+        def call() -> httpx.Response:
+            resp = self._client.post(self.cfg.target, json={"id": case.id, "input": case.input})
+            resp.raise_for_status()
+            return resp
+
+        start = time.perf_counter()
+        try:
+            resp = with_retries(call)
+            ctype = resp.headers.get("content-type", "")
+            output, retrieved = _coerce(resp.json() if "json" in ctype else resp.text)
+        except (ProviderError, TypeError, ValueError) as exc:
+            return SystemOutput(output="", error=str(exc))
+        return SystemOutput(
+            output=output, retrieved=retrieved, latency_ms=(time.perf_counter() - start) * 1000
+        )
+
+
+def make_system(
+    cfg: TargetConfig,
+    cache: ResponseCache | None = None,
+    client: httpx.Client | None = None,
+    search_path: str | None = None,
+) -> System:
+    kind = cfg.kind
+    if kind == "python":
+        return PythonSystem(cfg.target, search_path=search_path)
+    if kind == "http":
+        return HttpSystem(cfg, client=client)
+    provider: Provider = make_provider(cfg, client=client)
+    if cache is not None:
+        provider = CachedProvider(provider, cache, base_url=cfg.base_url)
+    return LLMSystem(cfg, provider)

evalproof-0.2.0.dist-info/METADATA

@@ -0,0 +1,279 @@
+Metadata-Version: 2.5
+Name: evalproof
+Version: 0.2.0
+Summary: Treat LLM evaluation as measurement: calibrate the judge, correct the pass rate, gate CI on significant regressions.
+Project-URL: Homepage, https://github.com/technobasant/evalproof
+Project-URL: Documentation, https://github.com/technobasant/evalproof#readme
+Project-URL: Source, https://github.com/technobasant/evalproof
+Project-URL: Issues, https://github.com/technobasant/evalproof/issues
+Project-URL: Changelog, https://github.com/technobasant/evalproof/blob/main/CHANGELOG.md
+Project-URL: Live demo, https://evalproof.streamlit.app
+Project-URL: Write-up, https://basantbhattarai.com.np/writing/eval-score-drop-twelve-answers/
+Author: Basant Bhattarai
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: calibration,ci,evaluation,llm,llm-as-a-judge,statistics
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Requires-Dist: httpx>=0.27
+Requires-Dist: numpy>=1.26
+Requires-Dist: pydantic>=2.7
+Requires-Dist: pyyaml>=6.0
+Description-Content-Type: text/markdown
+
+# evalproof
+
+[![PyPI](https://img.shields.io/pypi/v/evalproof)](https://pypi.org/project/evalproof/)
+[![Python](https://img.shields.io/pypi/pyversions/evalproof)](https://pypi.org/project/evalproof/)
+[![ci](https://github.com/technobasant/evalproof/actions/workflows/ci.yml/badge.svg)](https://github.com/technobasant/evalproof/actions/workflows/ci.yml)
+[![licence](https://img.shields.io/badge/licence-Apache--2.0-blue)](https://github.com/technobasant/evalproof/blob/main/LICENSE)
+[![Open in Streamlit](https://static.streamlit.io/badges/streamlit_badge_black_white.svg)](https://evalproof.streamlit.app)
+
+**Treat LLM evaluation as measurement.** Calibrate the judge, correct its pass rate, and
+gate CI on regressions that are real rather than noise.
+
+**Try it in the browser: [evalproof.streamlit.app](https://evalproof.streamlit.app).** Check whether
+a drop between two runs is real, or replay the run below and read the twelve answers that
+changed. It runs this repository's code; after a quiet spell it takes about half a minute to wake.
+
+An LLM judge is a classifier with error rates. If it passes bad answers at rate FPR and
+good answers at rate TPR, its pass rate converges to `FPR + (TPR − FPR) · p`, not to the
+true rate `p`. That is classify-and-count, and it is biased the way any classifier's count
+is — the effect is worked through with a seeded simulation in
+[*The classifier was 95% accurate. The trend it counted was a third too flat*](https://basantbhattarai.com.np/writing/count-prevalence-not-classifications/)
+([lab](https://github.com/technobasant/prevalence-shift)).
+
+evalproof:
+
+1. **measures the judge** against a small gold-labelled sample — confusion matrix, TPR,
+   FPR, Cohen's κ;
+2. **corrects its pass rate** with adjusted classify-and-count and prediction-powered
+   inference, each with a confidence interval;
+3. **compares runs on paired cases** — exact McNemar for pass/fail, paired bootstrap for
+   scores;
+4. **gates CI** only when a drop is both larger than your tolerance *and* statistically
+   significant, plus latency and cost budgets, with distinct exit codes.
+
+It is local-first: Ollama is the default provider, Anthropic and OpenAI are optional, and
+every model call is cached by content so re-runs are free and reproducible.
+
+## Install
+
+```bash
+pip install evalproof          # or: uv add evalproof
+uv tool install evalproof      # just the CLI
+```
+
+Python 3.11 to 3.14. `compare`, `calibrate` and `report` work on run files and need no
+model. `run` needs a system to evaluate: a Python function, an HTTP endpoint, a local
+Ollama model, or an Anthropic or OpenAI key.
+
+## What it found on a real run
+
+A local `qwen3:1.7b` support assistant for a fictional product, judged by `qwen3:8b`, 83
+questions, one Apple M5. Full method and every table in [MEASUREMENTS.md](https://github.com/technobasant/evalproof/blob/main/MEASUREMENTS.md).
+
+| Question | Measured |
+|---|---|
+| How good is the 8B judge? | TPR 92.6%, FPR 6.7%, Cohen's κ 0.78 against the answer key |
+| Did swapping the grounded prompt for a "friendly" one regress quality? | −4.8 pts on the judge, 8 cases worse vs 4 better, McNemar p = 0.39 — **gate warns, does not fail**; a delta-only gate would have failed it |
+| What did regress? | p95 latency, 1,469 → 4,422 ms; mean answer 19 → 77 tokens. A 2,500 ms budget fails the change with exit 3 |
+| Does correcting the judge's rate help? | On average yes (offset 4.8 → ~3.8 pts), but with 30 labels the interval doubles; at 83 cases the judge's bias is smaller than its own noise |
+| Was the gold trustworthy? | No: of 13 judge–key disagreements the key was wrong 7 times, the judge 4. Most of the "bias" corrected was the gold's |
+| Is pairwise judging safer? | No: 42% of verdicts flipped with the order of the two answers, and the judge preferred the candidate 42 to 6 — mostly where both answers were right and the candidate's was five times longer |
+| Is it reproducible? | 20/20 identical outputs and verdicts with the cache off; a warm-cache re-run took 0.05 s instead of 363 s |
+
+## Five-minute quickstart
+
+The offline example lives in the repository:
+
+```bash
+git clone https://github.com/technobasant/evalproof && cd evalproof
+uv sync
+
+# Offline: no model, no network. Four versions of a ticket router.
+for v in baseline regressed noisy refactored; do
+  uv run evalproof run examples/deterministic/suite.yaml \
+    --system "python:router:${v}_route" --out "runs/$v.json" --quiet
+done
+uv run evalproof compare runs/baseline.json runs/regressed.json \
+  --suite examples/deterministic/suite.yaml --gate; echo "exit $?"   # 1: real regression
+uv run evalproof compare runs/baseline.json runs/noisy.json \
+  --suite examples/deterministic/suite.yaml --gate; echo "exit $?"   # 0: 2 of 60 is noise
+```
+
+With Ollama installed, the LLM example is
+[`examples/support-qa`](https://github.com/technobasant/evalproof/blob/main/examples/support-qa) (`ollama pull qwen3:1.7b` and
+`ollama pull qwen3:8b`; about 6–10 minutes per run on an Apple M5).
+
+The browser app in [`app/`](https://github.com/technobasant/evalproof/blob/main/app) runs locally too:
+`uv run --with-requirements app/requirements.txt streamlit run app/streamlit_app.py`.
+
+## Concepts
+
+**Suite** — one YAML file: a JSONL golden set, the system under test, scorers, an optional
+judge, calibration settings and a gate.
+
+```yaml
+name: support-qa
+dataset: cases.jsonl              # {"id", "input", "reference", ...extra fields}
+system:
+  target: ollama:qwen3:1.7b       # or anthropic:…, openai:…, python:module:func, https://…
+  system_prompt_file: prompt.md
+  prompt_template: "{question}"
+  params: {temperature: 0, seed: 0, think: false}
+judge:
+  target: ollama:qwen3:8b
+scorers:
+  - {name: answer_key, type: regex, params: {any_of_field: accept, none_of_field: reject}}
+  - {name: judge, type: llm_judge, params: {rubric_file: rubric.md}}
+calibration: {judge_scorer: judge, gold_scorer: answer_key, gold_sample: 30}
+gate: {metric: judge, max_drop: 0.03, alpha: 0.05, min_cases: 40, max_p95_latency_ms: 2500}
+```
+
+**Run** — `evalproof run suite.yaml` writes one self-describing JSON file: every case's
+output, latency, tokens and scores, plus the dataset hash, seed, Ollama version and model
+digests.
+
+**Scorers** — `exact_match`, `contains`, `regex` (accept/reject answer keys),
+`json_schema`, `numeric_tolerance`, `recall_at_k`, `mrr`, `ndcg`, and `llm_judge`: a strict
+JSON verdict, one retry on an unparseable reply, and an explicit *undecided* state that is
+counted, never scored as a pass. `evalproof pairwise` judges two runs head to head in both
+orders and reports order-dependent verdicts as ties.
+
+**Calibrate** — `evalproof calibrate run.json --judge-scorer judge --labels gold.jsonl`
+(human labels) or `--gold-scorer answer_key --gold-sample 30`:
+
+| Estimate | What it is |
+|---|---|
+| raw judge pass rate | classify-and-count, Wilson interval |
+| gold labels only | the labelled sample alone |
+| ACC | `(q − FPR) / (TPR − FPR)`, bootstrap interval over both the judged set and the gold sample |
+| PPI | judge mean on unlabelled cases + mean (label − judge) on the gold sample, normal interval |
+
+**Compare and gate** — `evalproof compare baseline.json candidate.json --suite suite.yaml --gate`
+
+| Exit | Meaning |
+|---|---|
+| 0 | pass — possibly with warnings (a big drop that is not significant; a significant drop within tolerance) |
+| 1 | quality regression: drop ≥ `max_drop` **and** p < `alpha` |
+| 3 | budget breach: candidate p95 latency or cost over the limit |
+| 4 | cannot gate: fewer than `min_cases` paired cases, or the runs used different data |
+| 2 | usage or configuration error |
+
+## From Python
+
+The CLI is a thin layer over the same functions:
+
+```python
+from evalproof import GateConfig, calibrate, compare_runs, decide, load_run
+
+baseline = load_run("runs/baseline.json")
+candidate = load_run("runs/candidate.json")
+
+cmp = compare_runs(baseline, candidate)  # paired cases: exact McNemar, bootstrap intervals
+decision = decide(cmp, GateConfig(metric="judge", max_drop=0.03))
+print(decision.status, decision.exit_code, decision.warnings)
+
+report = calibrate(baseline, "judge", gold_scorer="answer_key", gold_sample=30)
+for est in report.estimates:  # raw judge rate, gold only, ACC, PPI
+    print(est.method, est.point, est.low, est.high)
+```
+
+The names in `evalproof.__all__` are the supported API. Other modules are internal and may
+change between minor versions; see the [changelog](https://github.com/technobasant/evalproof/blob/main/CHANGELOG.md).
+
+## Architecture
+
+The architecture diagram is in the [README on GitHub](https://github.com/technobasant/evalproof#architecture).
+
+## Decisions
+
+| Decision | Alternative | Why | ADR |
+|---|---|---|---|
+| Treat the judge as a classifier to be calibrated | Trust the judge's pass rate | Its count is biased by its own error rates, and the bias moves with the true rate | [0001](https://github.com/technobasant/evalproof/blob/main/docs/adr/0001-judge-is-a-classifier.md) |
+| Local Ollama by default, HTTP-only providers, content-addressed cache | Hosted APIs and vendor SDKs | Reproducible, free to re-run, tied to a model digest; no SDK dependency | [0002](https://github.com/technobasant/evalproof/blob/main/docs/adr/0002-local-first-providers.md) |
+| Gate on "large AND significant", on paired cases | "Fail if the score dropped by X" | On a few dozen cases, X-point drops are mostly noise, and a noisy gate gets switched off | [0003](https://github.com/technobasant/evalproof/blob/main/docs/adr/0003-gate-on-significance-not-delta.md) |
+| Gate one metric; report the rest | Gate every metric | Testing many metrics at α = 0.05 each inflates false failures | 0003 |
+| Pointwise verdicts for gating; pairwise as a diagnostic | Pairwise preference for gating | Measured: 42% of pairwise verdicts flipped with answer order, with a strong length preference | [MEASUREMENTS §6](https://github.com/technobasant/evalproof/blob/main/MEASUREMENTS.md) |
+| numpy and the standard library for statistics | SciPy, statsmodels | Small enough to read and to test against hand-worked values | — |
+
+## In CI
+
+The composite action runs `compare --gate`, appends the report to the job summary, and
+fails the job on exit codes 1, 3 or 4:
+
+```yaml
+- uses: technobasant/evalproof@v0.2.0
+  with:
+    baseline: eval/baseline.json     # produced on main, e.g. as a build artifact
+    candidate: eval/candidate.json   # produced on this branch
+    suite: eval/suite.yaml
+```
+
+This repository's own CI runs the offline example on every commit and asserts that the
+gate returns 1 for the real regression and 0 for the noisy and refactored candidates.
+
+## How it relates to other tools
+
+[promptfoo](https://www.promptfoo.dev/docs/intro/) (open-source, local evals of prompts,
+models and RAG pipelines with deterministic and model-graded assertions, a GitHub Action,
+and red teaming), [DeepEval](https://deepeval.com/docs/getting-started) (pytest-style
+LLM tests with research-backed metrics such as G-Eval), [Ragas](https://docs.ragas.io/en/stable/)
+(LLM-driven metrics and experiments for LLM and RAG applications) and
+[Inspect](https://inspect.aisi.org.uk/) (the UK AI Security Institute's framework for
+model and agent evaluations, with sandboxed tools and a log viewer) are broad evaluation
+frameworks.
+
+evalproof is deliberately narrow: it is the measurement layer — how much a judge's verdict
+is worth, and whether a difference between two runs is real. Its run file is plain,
+documented JSON, so it can sit beside an existing harness: produce the per-case verdicts
+however you like, then calibrate and gate here.
+
+## Limits
+
+* The measurements cover one machine, two small local models, one fictional domain and
+  83 cases. They show the method; they are not a benchmark of those models.
+* Calibration is only as good as its gold labels — [MEASUREMENTS §4](https://github.com/technobasant/evalproof/blob/main/MEASUREMENTS.md)
+  shows a regex answer key being wrong more often than the judge. Use human labels when
+  the decision matters.
+* ACC needs both classes in the gold sample and a judge better than chance; PPI needs the
+  gold sample to be random. evalproof reports when either does not hold rather than
+  printing a number.
+* The percentile-bootstrap p-value for continuous scores is an approximation; pass/fail
+  metrics use the exact McNemar test.
+* Cost tracking needs a price table in the suite for hosted models.
+
+## Roadmap
+
+* Stratified gold sampling (by tag) and per-tag calibration.
+* Multiple-comparison correction when more than one metric is gated.
+* A reasoning judge (`think: true`) measured against the same answer key.
+* Importers for other harnesses' per-case results.
+
+## Project
+
+[Changelog](https://github.com/technobasant/evalproof/blob/main/CHANGELOG.md) · [Contributing](https://github.com/technobasant/evalproof/blob/main/CONTRIBUTING.md) ·
+[Security policy](https://github.com/technobasant/evalproof/blob/main/SECURITY.md) · [Code of conduct](https://github.com/technobasant/evalproof/blob/main/CODE_OF_CONDUCT.md) ·
+[How to cite](https://github.com/technobasant/evalproof/blob/main/CITATION.cff). Releases are published to PyPI from GitHub Actions with
+[trusted publishing](https://docs.pypi.org/trusted-publishers/), and each file carries a
+signed provenance attestation.
+
+## Licence
+
+Apache-2.0. See [LICENSE](https://github.com/technobasant/evalproof/blob/main/LICENSE) and [NOTICE](https://github.com/technobasant/evalproof/blob/main/NOTICE).

evalproof-0.2.0.dist-info/RECORD

@@ -0,0 +1,30 @@
+evalproof/__init__.py,sha256=EXJgFmkOEU6CCP8mhb1k1B-r9Lt2v1zttIxP13LuiiE,1953
+evalproof/_version.py,sha256=8LOhs9njNsWQUbKWbELE0YghKdN7GOQChQgEnFWM4Ps,121
+evalproof/cache.py,sha256=hzJB7jV6hCzT6F_GZDB8NpVXh4dgiwtc-8Ni56WPAs8,3066
+evalproof/calibration.py,sha256=oRqg7qSnKKd2gwk7boNSYwsarYDLRlNKWb5Mwe3E2TY,9552
+evalproof/cli.py,sha256=qlLgxkhZysXOgVzP9FxUWzgoyTYRwu1rD7xiXKFiD00,9831
+evalproof/compare.py,sha256=iyNddsgjPLYJ1IC3KJyxs989tsYheukoDPMnsFD2wEI,5297
+evalproof/config.py,sha256=1R0Dxgegx_knJSGbFylfBi3pQK-aUPw0_S6E5-A8SEA,5329
+evalproof/dataset.py,sha256=5bvBaPajQxNnaUFAWwgEL6OnRRsQiT0WsYI7FPW3w1E,2346
+evalproof/gate.py,sha256=R-cm0TQaQWcnY8LkJOJy4hQNT2imK1MNV0_QnC51jt4,4036
+evalproof/models.py,sha256=g3AyW9rJRKuKrE1dNrZWvwADqhY3xxl4VEv01XCfR7k,3332
+evalproof/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+evalproof/report.py,sha256=q2fVojAQTlKiBfgxSbTl7uBEvsJkjvvaxO1zxj83IfA,5831
+evalproof/runner.py,sha256=6QCvComHEa02Ql28qnQiOqm0SUzsu8f7qn1caOH3Bt8,4724
+evalproof/stats.py,sha256=Xwt5k7g29uC7_l2rs-Vyw14XKYBr9Mn_APXy75ewXDE,4992
+evalproof/systems.py,sha256=pvAV02QVRnPsVZxRMivJDW-mlhPtAt1qcLCS3jnjNEI,5631
+evalproof/providers/__init__.py,sha256=YIptAL2kK6LU7rcuyUV2LrCv9KjpDjYwXCLz2aUzdis,1785
+evalproof/providers/anthropic.py,sha256=jogTjgxQCad3D-E-DAyFnfzgODB2pmago2Ujy3rCGpw,2623
+evalproof/providers/base.py,sha256=XNRiu5S1vyfwU1EzmaAPmL6v-vsHvOBteJ3jnRqv1Lk,2136
+evalproof/providers/ollama.py,sha256=MklL_Ex4vGeDc-fyV3NxscZwk7cRFgKDr3Zx7Tpd1Dk,2306
+evalproof/providers/openai.py,sha256=2mviallmw4BJOblE596z0_djOgVxvo-4MpZGwn7e3kA,2626
+evalproof/scorers/__init__.py,sha256=s-aCK5o39XASypzT-Z2cE3H61Asg3g9mqHiktyzFCSw,2205
+evalproof/scorers/deterministic.py,sha256=4u7wfl9WG4EQKbAErDCrSwTyzfCzd11ck8JS3btBzRk,8393
+evalproof/scorers/judge.py,sha256=crRCZI7XFOV-U_3Wxo0XZVYlsA-In1mCm_FnXJwxc4c,6365
+evalproof/scorers/retrieval.py,sha256=QAEKPPfdZWpR23g9ieNzsIIxv6Vt4QTY-pkC4JIyhYc,2291
+evalproof-0.2.0.dist-info/METADATA,sha256=eCcYpx36acVv13QinExbSu_w0Yg9v6cBgZkGz9C7_nE,15308
+evalproof-0.2.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+evalproof-0.2.0.dist-info/entry_points.txt,sha256=q81031vTHHlprNogYBcd0RNWW9UgchMn1kHCMDzZ_24,49
+evalproof-0.2.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+evalproof-0.2.0.dist-info/licenses/NOTICE,sha256=QKLv_qIUn1TOjv_xERUUCCiWJBxtuUJxTV--1WVCLjw,121
+evalproof-0.2.0.dist-info/RECORD,,

evalproof-0.2.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

evalproof-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+evalproof = evalproof.cli:main