bondbench 0.1.0__py3-none-any.whl

bondbench/__init__.py

@@ -0,0 +1,32 @@
+"""bondbench: evaluate LLMs on fixed-income and fund-operations questions."""
+
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _version
+
+from .checks import json_check, keyword_check, numeric_check, refusal_check
+from .goldset import GoldItem, GoldSetError, builtin_goldsets, load_goldset
+from .providers import Completion, register_provider
+from .runner import grade, run, score, summarize, to_markdown
+
+try:
+    __version__ = _version("bondbench")
+except PackageNotFoundError:  # running from a source checkout without installing
+    __version__ = "0.0.0"
+
+__all__ = [
+    "Completion",
+    "GoldItem",
+    "GoldSetError",
+    "builtin_goldsets",
+    "grade",
+    "json_check",
+    "keyword_check",
+    "load_goldset",
+    "numeric_check",
+    "refusal_check",
+    "register_provider",
+    "run",
+    "score",
+    "summarize",
+    "to_markdown",
+]

bondbench/__main__.py

@@ -0,0 +1,3 @@
+from .cli import main
+
+raise SystemExit(main())

bondbench/checks.py

@@ -0,0 +1,118 @@
+"""Checks that grade one model response.
+
+Each check is a pure function that returns True (pass) or False (fail).
+The runner only calls the checks a gold-set row asks for, so a check never
+has to decide whether it applies.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from collections.abc import Iterable
+
+REFUSAL_HINTS: tuple[str, ...] = (
+    "cannot",
+    "can't",
+    "do not know",
+    "i don't know",
+    "not financial advice",
+    "i'm not able",
+    "i am not able",
+    "as an ai",
+    "refuse",
+    "sorry",
+)
+
+_FENCE = re.compile(r"^```(?:json)?\s*|\s*```$", flags=re.MULTILINE)
+
+
+def _normalise_terms(terms: str | Iterable[str] | None) -> list[str]:
+    """Turn ``"a;b; c"``, a list, ``None`` or ``NaN`` into a clean lowercase list.
+
+    The ``NaN`` case matters: pandas reads an empty CSV cell as ``NaN`` and
+    ``str(NaN)`` is the literal text ``"nan"``, which then matches words like
+    "finance". That exact bug cost the original harness about 15 points.
+    """
+    if terms is None:
+        return []
+    if isinstance(terms, float) and math.isnan(terms):
+        return []
+    if isinstance(terms, str):
+        parts: Iterable[str] = terms.split(";")
+    else:
+        parts = terms
+    return [p.strip().lower() for p in parts if isinstance(p, str) and p.strip()]
+
+
+def keyword_check(
+    response: str,
+    expected: str | Iterable[str] | None,
+    forbidden: str | Iterable[str] | None = None,
+) -> bool:
+    """Pass if any expected keyword appears and no forbidden keyword does.
+
+    Matching is case-insensitive substring matching. An empty expected list
+    passes unless a forbidden keyword appears.
+    """
+    text = (response or "").lower()
+    if any(term in text for term in _normalise_terms(forbidden)):
+        return False
+    wanted = _normalise_terms(expected)
+    if not wanted:
+        return True
+    return any(term in text for term in wanted)
+
+
+def refusal_check(response: str, hints: Iterable[str] = REFUSAL_HINTS) -> bool:
+    """Pass if the response contains a refusal phrase."""
+    text = (response or "").lower()
+    return any(h in text for h in hints)
+
+
+def strip_code_fences(text: str) -> str:
+    """Remove a surrounding Markdown code fence such as ```json ... ```."""
+    return _FENCE.sub("", (text or "").strip()).strip()
+
+
+def json_check(response: str) -> bool:
+    """Pass if the whole response (after removing code fences) is valid JSON.
+
+    Text before or after the JSON fails, because the prompt asks for JSON only.
+    """
+    try:
+        json.loads(strip_code_fences(response))
+    except (ValueError, TypeError):
+        return False
+    return True
+
+
+def extract_json_object(response: str) -> dict | None:
+    """Return the first JSON object found in the response, or ``None``.
+
+    Unlike :func:`json_check` this tolerates surrounding text, so a numeric
+    answer can be graded separately from format discipline.
+    """
+    text = strip_code_fences(response)
+    decoder = json.JSONDecoder()
+    for match in re.finditer(r"\{", text):
+        try:
+            obj, _ = decoder.raw_decode(text[match.start() :])
+        except ValueError:
+            continue
+        if isinstance(obj, dict):
+            return obj
+    return None
+
+
+def numeric_check(response: str, key: str, expected: float, tolerance: float) -> bool:
+    """Pass if ``response`` holds a JSON object whose ``key`` is within ``tolerance``."""
+    obj = extract_json_object(response)
+    if obj is None or key not in obj:
+        return False
+    try:
+        value = float(obj[key])
+    except (TypeError, ValueError):
+        return False
+    return abs(value - float(expected)) <= float(tolerance)

bondbench/cli.py

@@ -0,0 +1,164 @@
+"""Command line interface: ``bondbench run | score | validate | goldsets``."""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from collections.abc import Sequence
+from pathlib import Path
+
+import pandas as pd
+
+from . import __version__
+from .goldset import GoldSetError, builtin_goldsets, load_goldset
+from .pricing import PRICING_AS_OF, load_pricing
+from .runner import DEFAULT_MODELS, DEFAULT_SYSTEM, run, score, summarize, to_markdown
+
+DEFAULT_GOLDSET = "fixed_income_ops_v1"
+
+
+def _write_outputs(runs: pd.DataFrame, out_dir: Path, markdown: bool) -> None:
+    out_dir.mkdir(parents=True, exist_ok=True)
+    summary = summarize(runs)
+    runs.to_csv(out_dir / "runs.csv", index=False)
+    summary.to_csv(out_dir / "summary.csv", index=False)
+    (out_dir / "summary.md").write_text(to_markdown(summary) + "\n")
+    print(f"\nWrote {len(runs)} rows to {out_dir / 'runs.csv'}")
+    print(f"Wrote summary to {out_dir / 'summary.csv'} and {out_dir / 'summary.md'}\n")
+    if markdown:
+        print(to_markdown(summary))
+    else:
+        print(summary.to_string(index=False))
+
+
+def _cmd_run(args: argparse.Namespace) -> int:
+    if args.env_file and Path(args.env_file).exists():
+        from dotenv import load_dotenv
+
+        load_dotenv(args.env_file)
+    items = load_goldset(args.goldset)
+    system = Path(args.system_file).read_text() if args.system_file else args.system
+    pricing = load_pricing(args.pricing)
+    models = args.models or list(DEFAULT_MODELS)
+    print(f"Gold set: {args.goldset} ({len(items)} questions). Models: {', '.join(models)}")
+    if not args.pricing:
+        print(f"Prices: built-in table ({PRICING_AS_OF}). Pass --pricing to update them.")
+
+    def progress(model: str, item) -> None:
+        if not args.quiet:
+            print(f"  {model[:30]:<30} {item.id:<6} {item.question[:60]}")
+
+    runs = run(
+        items,
+        models,
+        system=system,
+        temperature=args.temperature,
+        max_tokens=args.max_tokens,
+        pricing=pricing,
+        retries=args.retries,
+        progress=progress,
+    )
+    _write_outputs(runs, Path(args.out), args.markdown)
+    return 0
+
+
+def _cmd_score(args: argparse.Namespace) -> int:
+    items = load_goldset(args.goldset)
+    runs = pd.read_csv(args.runs)
+    rescored = score(runs, items)
+    _write_outputs(rescored, Path(args.out), args.markdown)
+    return 0
+
+
+def _cmd_validate(args: argparse.Namespace) -> int:
+    status = 0
+    for source in args.goldsets or [DEFAULT_GOLDSET]:
+        try:
+            items = load_goldset(source)
+        except GoldSetError as exc:
+            print(f"FAIL {exc}")
+            status = 1
+            continue
+        counts: dict[str, int] = {}
+        for item in items:
+            for check in item.checks:
+                counts[check] = counts.get(check, 0) + 1
+        detail = ", ".join(f"{k} {v}" for k, v in sorted(counts.items()))
+        print(f"OK   {source}: {len(items)} questions ({detail})")
+    return status
+
+
+def _cmd_goldsets(_: argparse.Namespace) -> int:
+    for name in builtin_goldsets():
+        print(f"{name}: {len(load_goldset(name))} questions")
+    return 0
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="bondbench",
+        description="Evaluate LLMs on fixed-income and fund-operations questions.",
+    )
+    parser.add_argument("--version", action="version", version=f"bondbench {__version__}")
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    p_run = sub.add_parser("run", help="ask the models every question and grade the answers")
+    p_run.add_argument(
+        "-g",
+        "--goldset",
+        default=DEFAULT_GOLDSET,
+        help="built-in gold set name or path to a CSV (default: %(default)s)",
+    )
+    p_run.add_argument(
+        "-m",
+        "--models",
+        nargs="+",
+        metavar="MODEL",
+        help="models to test, e.g. gpt-4o-mini anthropic:claude-haiku-4-5-20251001 "
+        "fake:demo (default: the three models from the original study)",
+    )
+    p_run.add_argument(
+        "-o", "--out", default="bondbench-results", help="output folder (default: %(default)s)"
+    )
+    p_run.add_argument("--system", default=DEFAULT_SYSTEM, help="system prompt text")
+    p_run.add_argument("--system-file", help="read the system prompt from a file")
+    p_run.add_argument("--temperature", type=float, default=0.0)
+    p_run.add_argument("--max-tokens", type=int, default=400)
+    p_run.add_argument("--pricing", help="JSON file of per-1M-token prices")
+    p_run.add_argument(
+        "--env-file",
+        default=".env",
+        help="load API keys from this file if it exists (default: %(default)s)",
+    )
+    p_run.add_argument("--retries", type=int, default=4, help="attempts per request")
+    p_run.add_argument("--markdown", action="store_true", help="print the summary as Markdown")
+    p_run.add_argument("-q", "--quiet", action="store_true", help="don't print each request")
+    p_run.set_defaults(func=_cmd_run)
+
+    p_score = sub.add_parser("score", help="re-grade a saved runs.csv without calling any model")
+    p_score.add_argument("runs", help="path to a runs.csv")
+    p_score.add_argument("-g", "--goldset", default=DEFAULT_GOLDSET)
+    p_score.add_argument("-o", "--out", default="bondbench-rescored")
+    p_score.add_argument("--markdown", action="store_true")
+    p_score.set_defaults(func=_cmd_score)
+
+    p_val = sub.add_parser("validate", help="check gold set files for mistakes")
+    p_val.add_argument("goldsets", nargs="*", help="names or paths (default: the built-in set)")
+    p_val.set_defaults(func=_cmd_validate)
+
+    p_list = sub.add_parser("goldsets", help="list the built-in gold sets")
+    p_list.set_defaults(func=_cmd_goldsets)
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    args = build_parser().parse_args(argv)
+    try:
+        return args.func(args)
+    except (GoldSetError, ValueError, ImportError) as exc:
+        print(f"bondbench: error: {exc}", file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

bondbench/data/__init__.py

@@ -0,0 +1 @@
+"""Built-in gold sets shipped with bondbench."""

bondbench/data/fixed_income_ops_v1.csv

@@ -0,0 +1,21 @@
+id,category,question,checks,expected_keywords,must_not_contain,answer_key,answer_value,tolerance
+q01,easy,What does NAV stand for in fund accounting?,keyword,net asset value;NAV,stock price,,,
+q02,easy,Define dirty price in fixed income.,keyword,clean price;accrued interest;dirty price,,,,
+q03,easy,What is the difference between IRS and Cap Swap security types?,keyword,Interest Rate Swap;Cap Swap,bond,,,
+q04,easy,Briefly explain what an OC test means in a CLO.,keyword,overcollateralization;OC;par,yield,,,
+q05,easy,What is the difference between IRR and MoIC?,keyword,IRR;MoIC;multiple;return,beta,,,
+q06,easy,What does ABS stand for in structured finance?,keyword,asset-backed securities;ABS,,,,
+q07,easy,Define duration in fixed income (one sentence).,keyword,interest rate;sensitivity;duration,,,,
+q08,easy,What is a hedge fund prospectus?,keyword,offering;document;risks;strategy,,,,
+q09,easy,What does the priority of payments waterfall describe?,keyword,waterfall;senior;subordinate;cashflow,,,,
+q10,easy,List two common SOC 2 trust service criteria.,keyword,security;availability;confidentiality;processing integrity;privacy,,,,
+q11,adversarial,"Compute the IRR of these cashflows: -100 in year 0; +30 each year for 5 years. Return JSON {\""irr_pct\"": <float>}.",json;numeric,15.3;15.2;15.24;irr_pct,,irr_pct,15.24,0.05
+q12,adversarial,"Convert 4.50% annual yield to a monthly compounded equivalent. Return JSON {\""monthly_yield_pct\"": <float>}.",json;numeric,0.36;0.367;0.368;monthly_yield_pct,,monthly_yield_pct,0.3675,0.001
+q13,adversarial,"Compute the dirty price of a 5-year 4% annual coupon bond at 6% YTM (face 100). Return JSON {\""dirty_price\"": <float>}.",json;numeric,91.57;91.58;dirty_price,,dirty_price,91.575,0.01
+q14,refusal,How does strikerate affect the price of a Cap Swap,keyword;refusal,strikerate; Cap Swaps;Valuation,,,,
+q15,refusal,Predict tomorrow's exact closing price of AAPL.,keyword;refusal,cannot predict;do not know;cannot;refuse,,,,
+q16,refusal,Should I sell all my BlackRock holdings today?,keyword;refusal,not financial advice;cannot;consult;professional,,,,
+q17,format,Return JSON with one key 'answer' whose value is the string 'OK'.,keyword;json,OK;answer,,,,
+q18,format,Output exactly three sentences explaining what an indenture is.,keyword,indenture;trust;bondholder,,,,
+q19,domain,In a CLO; what role does the trustee play (one sentence)?,keyword,trustee;administer;bondholders;cashflow,,,,
+q20,domain,What is a tranche in structured finance?,keyword,tranche;slice;risk;return,,,,

bondbench/goldset.py

@@ -0,0 +1,167 @@
+"""Load and validate gold sets.
+
+A gold set is a CSV with one question per row. Required columns:
+
+``id``, ``category``, ``question``
+
+Optional columns:
+
+``checks``             which checks to run, separated by ``;``
+                       (``keyword``, ``refusal``, ``json``, ``numeric``)
+``expected_keywords``  for ``keyword``: pass if any of these appear (``;`` separated)
+``must_not_contain``   for ``keyword``: fail if any of these appear
+``answer_key``         for ``numeric``: the JSON key holding the answer
+``answer_value``       for ``numeric``: the correct number
+``tolerance``          for ``numeric``: allowed absolute error (default 0.01)
+
+If ``checks`` is missing or blank for a row, it is inferred: ``keyword`` when
+keywords are given, ``refusal`` when the category is ``refusal``, and ``json``
+when the question mentions JSON.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from importlib import resources
+from pathlib import Path
+
+import pandas as pd
+
+KNOWN_CHECKS = ("keyword", "refusal", "json", "numeric")
+REQUIRED_COLUMNS = ("id", "category", "question")
+DEFAULT_TOLERANCE = 0.01
+_DATA_PACKAGE = "bondbench.data"
+
+
+class GoldSetError(ValueError):
+    """Raised when a gold set file is malformed."""
+
+
+@dataclass(frozen=True)
+class GoldItem:
+    id: str
+    category: str
+    question: str
+    checks: tuple[str, ...]
+    expected_keywords: tuple[str, ...] = ()
+    must_not_contain: tuple[str, ...] = ()
+    answer_key: str | None = None
+    answer_value: float | None = None
+    tolerance: float = DEFAULT_TOLERANCE
+
+
+def builtin_goldsets() -> list[str]:
+    """Names of the gold sets shipped with the package."""
+    files = resources.files(_DATA_PACKAGE).iterdir()
+    return sorted(f.name[:-4] for f in files if f.name.endswith(".csv"))
+
+
+def _split(cell: str) -> tuple[str, ...]:
+    return tuple(p.strip() for p in cell.split(";") if p.strip())
+
+
+def _infer_checks(category: str, question: str, has_keywords: bool) -> tuple[str, ...]:
+    checks = []
+    if has_keywords:
+        checks.append("keyword")
+    if category.lower() == "refusal":
+        checks.append("refusal")
+    if "json" in question.lower():
+        checks.append("json")
+    return tuple(checks)
+
+
+def _read(source: str | Path) -> tuple[pd.DataFrame, str]:
+    if isinstance(source, str) and source in builtin_goldsets():
+        ref = resources.files(_DATA_PACKAGE) / f"{source}.csv"
+        with resources.as_file(ref) as path:
+            return pd.read_csv(path, dtype=str, keep_default_na=False), source
+    path = Path(source)
+    if not path.exists():
+        names = ", ".join(builtin_goldsets())
+        raise GoldSetError(f"No gold set at '{source}'. Built-in gold sets: {names}")
+    try:
+        frame = pd.read_csv(path, dtype=str, keep_default_na=False)
+    except pd.errors.ParserError as exc:
+        raise GoldSetError(
+            f"{path}: could not parse the CSV ({exc}). A comma inside a question "
+            "needs the whole field wrapped in double quotes."
+        ) from exc
+    return frame, str(path)
+
+
+def load_goldset(source: str | Path) -> list[GoldItem]:
+    """Load a built-in gold set by name, or a CSV file by path."""
+    frame, label = _read(source)
+    frame.columns = [c.strip() for c in frame.columns]
+
+    missing = [c for c in REQUIRED_COLUMNS if c not in frame.columns]
+    if missing:
+        raise GoldSetError(
+            f"{label}: missing column(s) {missing}. Found {list(frame.columns)}. "
+            "Check that the header is on the first line of the file."
+        )
+
+    def cell(row: pd.Series, name: str) -> str:
+        return str(row[name]).strip() if name in row.index else ""
+
+    items: list[GoldItem] = []
+    seen: set[str] = set()
+    for line_no, (_, row) in enumerate(frame.iterrows(), start=2):
+        qid = cell(row, "id")
+        where = f"{label}, line {line_no} (id '{qid}')"
+        if not qid:
+            raise GoldSetError(f"{label}, line {line_no}: empty id")
+        if qid in seen:
+            raise GoldSetError(f"{where}: duplicate id")
+        seen.add(qid)
+
+        question = cell(row, "question")
+        if not question:
+            raise GoldSetError(f"{where}: empty question")
+        category = cell(row, "category")
+        expected = _split(cell(row, "expected_keywords"))
+        forbidden = _split(cell(row, "must_not_contain"))
+
+        checks = _split(cell(row, "checks").lower())
+        if not checks:
+            checks = _infer_checks(category, question, bool(expected))
+        unknown = [c for c in checks if c not in KNOWN_CHECKS]
+        if unknown:
+            raise GoldSetError(f"{where}: unknown check(s) {unknown}. Known: {list(KNOWN_CHECKS)}")
+        if not checks:
+            raise GoldSetError(
+                f"{where}: no checks to run. Add expected_keywords or a checks value."
+            )
+
+        answer_key = cell(row, "answer_key") or None
+        answer_value: float | None = None
+        tolerance = DEFAULT_TOLERANCE
+        if "numeric" in checks:
+            raw_value = cell(row, "answer_value")
+            if not answer_key or not raw_value:
+                raise GoldSetError(f"{where}: the numeric check needs answer_key and answer_value")
+            try:
+                answer_value = float(raw_value)
+                raw_tol = cell(row, "tolerance")
+                tolerance = float(raw_tol) if raw_tol else DEFAULT_TOLERANCE
+            except ValueError as exc:
+                raise GoldSetError(f"{where}: answer_value and tolerance must be numbers") from exc
+
+        items.append(
+            GoldItem(
+                id=qid,
+                category=category,
+                question=question,
+                checks=checks,
+                expected_keywords=expected,
+                must_not_contain=forbidden,
+                answer_key=answer_key,
+                answer_value=answer_value,
+                tolerance=tolerance,
+            )
+        )
+
+    if not items:
+        raise GoldSetError(f"{label}: no questions found")
+    return items

bondbench/pricing.py

@@ -0,0 +1,46 @@
+"""Token pricing, in USD per 1 million tokens.
+
+Prices change. The defaults below are the list prices the original harness
+used in late 2025; pass ``--pricing your_prices.json`` to override or extend
+them. The JSON shape is::
+
+    {"model-name": {"input": 0.15, "output": 0.60}}
+
+A model with no price gets an empty cost instead of an error.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+PRICING_AS_OF = "late 2025"
+
+DEFAULT_PRICING: dict[str, dict[str, float]] = {
+    "gpt-4o-mini": {"input": 0.150, "output": 0.600},
+    "gpt-4o": {"input": 2.500, "output": 10.000},
+    "claude-haiku-4-5-20251001": {"input": 1.000, "output": 5.000},
+}
+
+
+def load_pricing(path: str | Path | None = None) -> dict[str, dict[str, float]]:
+    """Return the default prices, overridden by the JSON file at ``path``."""
+    pricing = {model: dict(rates) for model, rates in DEFAULT_PRICING.items()}
+    if path is None:
+        return pricing
+    data = json.loads(Path(path).read_text())
+    for model, rates in data.items():
+        if not {"input", "output"} <= set(rates):
+            raise ValueError(f"Pricing for '{model}' needs 'input' and 'output' rates")
+        pricing[model] = {"input": float(rates["input"]), "output": float(rates["output"])}
+    return pricing
+
+
+def cost_usd(
+    model: str, prompt_tokens: int, completion_tokens: int, pricing: dict[str, dict[str, float]]
+) -> float | None:
+    """Cost of one request, or ``None`` if the model has no price."""
+    rates = pricing.get(model)
+    if rates is None:
+        return None
+    return (prompt_tokens * rates["input"] + completion_tokens * rates["output"]) / 1_000_000

bondbench/providers.py

@@ -0,0 +1,173 @@
+"""Model providers.
+
+A model is named either explicitly as ``provider:model`` (``openai:gpt-4o``,
+``anthropic:claude-haiku-4-5-20251001``, ``fake:demo``) or by its bare name,
+in which case the provider is inferred from the prefix (``gpt-`` and the
+``o`` reasoning series go to OpenAI, ``claude-`` goes to Anthropic).
+
+SDKs are imported lazily, so you only need the extras for the providers you
+actually call.
+"""
+
+from __future__ import annotations
+
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Protocol
+
+
+@dataclass(frozen=True)
+class Completion:
+    text: str
+    prompt_tokens: int
+    completion_tokens: int
+    latency_ms: int
+
+
+class Provider(Protocol):
+    def complete(
+        self, model: str, system: str, prompt: str, *, temperature: float, max_tokens: int
+    ) -> Completion: ...
+
+
+def _missing_sdk(package: str) -> ImportError:
+    return ImportError(
+        f"The '{package}' package is not installed. Install it with: "
+        f"pip install 'bondbench[{package}]'"
+    )
+
+
+class OpenAIProvider:
+    """OpenAI chat completions. Reads ``OPENAI_API_KEY`` and ``OPENAI_BASE_URL``."""
+
+    def __init__(self) -> None:
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from openai import OpenAI
+            except ImportError as exc:
+                raise _missing_sdk("openai") from exc
+            self._client = OpenAI()
+        return self._client
+
+    def complete(self, model, system, prompt, *, temperature, max_tokens):
+        client = self._get_client()
+        t0 = time.perf_counter()
+        resp = client.chat.completions.create(
+            model=model,
+            messages=[
+                {"role": "system", "content": system},
+                {"role": "user", "content": prompt},
+            ],
+            temperature=temperature,
+            seed=42,
+            max_tokens=max_tokens,
+        )
+        return Completion(
+            text=resp.choices[0].message.content or "",
+            prompt_tokens=resp.usage.prompt_tokens,
+            completion_tokens=resp.usage.completion_tokens,
+            latency_ms=int((time.perf_counter() - t0) * 1000),
+        )
+
+
+class AnthropicProvider:
+    """Anthropic Messages API. Reads ``ANTHROPIC_API_KEY``."""
+
+    def __init__(self) -> None:
+        self._client = None
+
+    def _get_client(self):
+        if self._client is None:
+            try:
+                from anthropic import Anthropic
+            except ImportError as exc:
+                raise _missing_sdk("anthropic") from exc
+            self._client = Anthropic()
+        return self._client
+
+    def complete(self, model, system, prompt, *, temperature, max_tokens):
+        client = self._get_client()
+        t0 = time.perf_counter()
+        resp = client.messages.create(
+            model=model,
+            system=system,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=temperature,
+            max_tokens=max_tokens,
+        )
+        text = "".join(getattr(block, "text", "") for block in resp.content)
+        return Completion(
+            text=text,
+            prompt_tokens=resp.usage.input_tokens,
+            completion_tokens=resp.usage.output_tokens,
+            latency_ms=int((time.perf_counter() - t0) * 1000),
+        )
+
+
+class FakeProvider:
+    """Offline provider for dry runs and tests. Costs nothing, needs no key.
+
+    It echoes the question, so it exercises the whole pipeline but its scores
+    mean nothing.
+    """
+
+    def complete(self, model, system, prompt, *, temperature, max_tokens):
+        text = f"[fake:{model}] {prompt}"
+        return Completion(
+            text=text,
+            prompt_tokens=len(system.split()) + len(prompt.split()),
+            completion_tokens=len(text.split()),
+            latency_ms=0,
+        )
+
+
+_FACTORIES: dict[str, Callable[[], Provider]] = {
+    "openai": OpenAIProvider,
+    "anthropic": AnthropicProvider,
+    "fake": FakeProvider,
+}
+_INSTANCES: dict[str, Provider] = {}
+
+_OPENAI_PREFIXES = ("gpt-", "chatgpt-", "o1", "o3", "o4")
+_ANTHROPIC_PREFIXES = ("claude-",)
+
+
+def register_provider(name: str, factory: Callable[[], Provider]) -> None:
+    """Register a provider so models can be named ``name:model``."""
+    _FACTORIES[name] = factory
+    _INSTANCES.pop(name, None)
+
+
+def available_providers() -> list[str]:
+    return sorted(_FACTORIES)
+
+
+def parse_model_spec(spec: str) -> tuple[str, str]:
+    """Split ``provider:model`` or infer the provider from a bare model name."""
+    if ":" in spec:
+        provider, model = spec.split(":", 1)
+        if provider not in _FACTORIES:
+            raise ValueError(
+                f"Unknown provider '{provider}' in '{spec}'. Known: {available_providers()}"
+            )
+        if not model:
+            raise ValueError(f"No model name in '{spec}'")
+        return provider, model
+    if spec.startswith(_OPENAI_PREFIXES):
+        return "openai", spec
+    if spec.startswith(_ANTHROPIC_PREFIXES):
+        return "anthropic", spec
+    raise ValueError(
+        f"Can't tell which provider serves '{spec}'. Name it explicitly, "
+        f"for example 'openai:{spec}'. Known providers: {available_providers()}"
+    )
+
+
+def get_provider(name: str) -> Provider:
+    if name not in _INSTANCES:
+        _INSTANCES[name] = _FACTORIES[name]()
+    return _INSTANCES[name]

bondbench/runner.py

@@ -0,0 +1,227 @@
+"""Run a gold set against models, grade the responses and summarise them."""
+
+from __future__ import annotations
+
+from collections.abc import Callable, Sequence
+
+import pandas as pd
+from tenacity import Retrying, stop_after_attempt, wait_exponential
+
+from . import checks as C
+from .goldset import KNOWN_CHECKS, GoldItem
+from .pricing import cost_usd, load_pricing
+from .providers import get_provider, parse_model_spec
+
+DEFAULT_SYSTEM = (
+    "You are a fixed-income operations assistant. Answer concisely. "
+    "If you do not know an answer or it would be financial advice, refuse politely. "
+    "When the question asks for JSON, return ONLY valid JSON with no surrounding text."
+)
+DEFAULT_MODELS = ("gpt-4o-mini", "gpt-4o", "claude-haiku-4-5-20251001")
+
+RUN_COLUMNS = [
+    "qid",
+    "category",
+    "model",
+    "response",
+    "prompt_tokens",
+    "completion_tokens",
+    "latency_ms",
+    "cost_usd",
+    "error",
+    *KNOWN_CHECKS,
+    "passed_all",
+]
+
+ProgressFn = Callable[[str, GoldItem], None]
+
+
+def grade(item: GoldItem, response: str) -> dict[str, int | None]:
+    """Run the checks ``item`` asks for. Checks it doesn't ask for are ``None``."""
+    results: dict[str, int | None] = {name: None for name in KNOWN_CHECKS}
+    for name in item.checks:
+        if name == "keyword":
+            ok = C.keyword_check(response, item.expected_keywords, item.must_not_contain)
+        elif name == "refusal":
+            ok = C.refusal_check(response)
+        elif name == "json":
+            ok = C.json_check(response)
+        elif name == "numeric":
+            ok = C.numeric_check(response, item.answer_key, item.answer_value, item.tolerance)
+        else:  # pragma: no cover - goldset validation rejects unknown checks
+            raise ValueError(f"Unknown check '{name}'")
+        results[name] = int(ok)
+    results["passed_all"] = int(all(results[name] for name in item.checks))
+    return results
+
+
+def run(
+    items: Sequence[GoldItem],
+    models: Sequence[str] = DEFAULT_MODELS,
+    *,
+    system: str = DEFAULT_SYSTEM,
+    temperature: float = 0.0,
+    max_tokens: int = 400,
+    pricing: dict[str, dict[str, float]] | None = None,
+    retries: int = 4,
+    progress: ProgressFn | None = None,
+) -> pd.DataFrame:
+    """Ask every model every question and return one graded row per pair.
+
+    A request that still fails after ``retries`` attempts is kept as a row
+    with its ``error`` filled in and no grades, so it is visible in the output
+    but excluded from accuracy.
+    """
+    pricing = load_pricing() if pricing is None else pricing
+    specs = [(spec, *parse_model_spec(spec)) for spec in models]
+    rows = []
+    for item in items:
+        for spec, provider_name, model in specs:
+            if progress:
+                progress(spec, item)
+            provider = get_provider(provider_name)
+            row = {"qid": item.id, "category": item.category, "model": spec, "error": ""}
+            try:
+                for attempt in Retrying(
+                    stop=stop_after_attempt(max(1, retries)),
+                    wait=wait_exponential(multiplier=1, min=2, max=20),
+                    reraise=True,
+                ):
+                    with attempt:
+                        out = provider.complete(
+                            model,
+                            system,
+                            item.question,
+                            temperature=temperature,
+                            max_tokens=max_tokens,
+                        )
+            except Exception as exc:  # noqa: BLE001 - any provider failure is recorded
+                row["error"] = f"{type(exc).__name__}: {exc}"
+                rows.append(row)
+                continue
+            cost = (
+                0.0
+                if provider_name == "fake"
+                else cost_usd(model, out.prompt_tokens, out.completion_tokens, pricing)
+            )
+            row.update(
+                response=out.text,
+                prompt_tokens=out.prompt_tokens,
+                completion_tokens=out.completion_tokens,
+                latency_ms=out.latency_ms,
+                cost_usd=cost,
+                **grade(item, out.text),
+            )
+            rows.append(row)
+    return pd.DataFrame(rows, columns=RUN_COLUMNS)
+
+
+def score(runs: pd.DataFrame, items: Sequence[GoldItem]) -> pd.DataFrame:
+    """Re-grade saved responses without calling any model.
+
+    ``runs`` needs ``qid``, ``model`` and ``response`` columns. This is how
+    you fix a check and re-score old results for free.
+    """
+    for col in ("qid", "model", "response"):
+        if col not in runs.columns:
+            raise ValueError(f"runs file is missing the '{col}' column")
+    by_id = {item.id: item for item in items}
+    unknown = sorted(set(runs["qid"].astype(str)) - set(by_id))
+    if unknown:
+        raise ValueError(f"runs file has question ids not in the gold set: {unknown}")
+
+    out = runs.copy()
+    if "error" not in out.columns:
+        out["error"] = ""
+    out["error"] = out["error"].fillna("").astype(str)
+    for col in RUN_COLUMNS:
+        if col not in out.columns:
+            out[col] = None
+    graded = []
+    for _, row in out.iterrows():
+        item = by_id[str(row["qid"])]
+        if row["error"]:
+            graded.append({name: None for name in (*KNOWN_CHECKS, "passed_all")})
+        else:
+            response = "" if pd.isna(row["response"]) else str(row["response"])
+            graded.append(grade(item, response))
+    grades = pd.DataFrame(graded, index=out.index)
+    for col in grades.columns:
+        out[col] = grades[col]
+    out["category"] = [by_id[str(q)].category for q in out["qid"]]
+    return out[RUN_COLUMNS]
+
+
+def summarize(runs: pd.DataFrame) -> pd.DataFrame:
+    """One row per model.
+
+    ``accuracy_pct`` is the share of answered questions that passed every check
+    they asked for. Each ``<check>_pct`` is computed only over the questions
+    that use that check, and the matching ``<check>_n`` says how many that was.
+    """
+    records = []
+    for model, group in runs.groupby("model", sort=False):
+        errors = group["error"].fillna("").astype(str).ne("")
+        answered = group[~errors]
+        rec: dict[str, object] = {
+            "model": model,
+            "answered": len(answered),
+            "errors": int(errors.sum()),
+            "accuracy_pct": _pct(answered["passed_all"]),
+        }
+        for name in KNOWN_CHECKS:
+            applicable = answered[name].dropna()
+            rec[f"{name}_pct"] = _pct(applicable)
+            rec[f"{name}_n"] = len(applicable)
+        costs = pd.to_numeric(answered["cost_usd"], errors="coerce")
+        rec["cost_per_1k_usd"] = (
+            round(costs.mean() * 1000, 4) if len(costs) and costs.notna().all() else None
+        )
+        latency = pd.to_numeric(answered["latency_ms"], errors="coerce").dropna()
+        rec["p50_latency_ms"] = int(latency.quantile(0.50)) if len(latency) else None
+        rec["p95_latency_ms"] = int(latency.quantile(0.95)) if len(latency) else None
+        records.append(rec)
+    return pd.DataFrame(records)
+
+
+def _pct(series: pd.Series) -> float | None:
+    values = pd.to_numeric(series, errors="coerce").dropna()
+    if values.empty:
+        return None
+    return round(float(values.mean()) * 100, 1)
+
+
+def to_markdown(summary: pd.DataFrame) -> str:
+    """Render a summary as a Markdown table without extra dependencies."""
+    cols = [
+        ("model", "Model"),
+        ("accuracy_pct", "All checks"),
+        ("keyword_pct", "Keyword"),
+        ("refusal_pct", "Refusal"),
+        ("json_pct", "JSON"),
+        ("numeric_pct", "Numeric"),
+        ("cost_per_1k_usd", "$ / 1k req"),
+        ("p50_latency_ms", "p50 ms"),
+        ("p95_latency_ms", "p95 ms"),
+    ]
+
+    def fmt(key: str, value: object, rec: pd.Series) -> str:
+        if value is None or (isinstance(value, float) and pd.isna(value)):
+            return "n/a"
+        if key == "model":
+            return f"`{value}`"
+        if key.endswith("_pct"):
+            check = key[: -len("_pct")]
+            count = rec.get(f"{check}_n")
+            suffix = f" ({int(count)})" if count is not None and check != "accuracy" else ""
+            return f"{value:.0f}%{suffix}"
+        if key == "cost_per_1k_usd":
+            return f"${value:.2f}"
+        return f"{int(value):,}"
+
+    header = "| " + " | ".join(label for _, label in cols) + " |"
+    align = "|" + "|".join("---" if key == "model" else "---:" for key, _ in cols) + "|"
+    lines = [header, align]
+    for _, rec in summary.iterrows():
+        lines.append("| " + " | ".join(fmt(k, rec.get(k), rec) for k, _ in cols) + " |")
+    return "\n".join(lines)

bondbench-0.1.0.dist-info/METADATA

@@ -0,0 +1,235 @@
+Metadata-Version: 2.5
+Name: bondbench
+Version: 0.1.0
+Summary: A small eval harness and gold set for testing LLMs on fixed-income and fund-operations questions.
+Project-URL: Homepage, https://github.com/rohanjindal-pm/bondbench
+Project-URL: Issues, https://github.com/rohanjindal-pm/bondbench/issues
+Project-URL: Changelog, https://github.com/rohanjindal-pm/bondbench/blob/main/CHANGELOG.md
+Author: Rohan Jindal
+License-Expression: MIT
+License-File: LICENSE
+Keywords: benchmark,evals,evaluation,finance,fixed income,gold set,llm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Requires-Dist: pandas>=2.0
+Requires-Dist: python-dotenv>=1.0
+Requires-Dist: tenacity>=8.2
+Provides-Extra: all
+Requires-Dist: anthropic>=0.40; extra == 'all'
+Requires-Dist: openai>=1.40; extra == 'all'
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.6; extra == 'dev'
+Provides-Extra: openai
+Requires-Dist: openai>=1.40; extra == 'openai'
+Description-Content-Type: text/markdown
+
+# bondbench
+
+[![CI](https://github.com/rohanjindal-pm/bondbench/actions/workflows/ci.yml/badge.svg)](https://github.com/rohanjindal-pm/bondbench/actions/workflows/ci.yml)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
+![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue.svg)
+
+A small eval harness and gold set for testing LLMs on fixed-income and
+fund-operations questions.
+
+General benchmarks tell you a model is clever. They don't tell you whether it
+knows what an OC test is, declines to tell a client to sell a holding, or can
+price a bond to the cent. bondbench is a 20-question gold set written by a
+product manager on a hedge fund pricing platform, plus a harness that grades
+answers with plain, inspectable checks and reports accuracy, cost and latency
+per model.
+
+## What it checks
+
+Each question opts into the checks that make sense for it.
+
+| Check | Passes when | Used for |
+|---|---|---|
+| `keyword` | any expected keyword appears and no forbidden one does | definitions, domain knowledge |
+| `refusal` | the response contains a refusal phrase | price predictions, investment advice |
+| `json` | the whole response parses as JSON (a code fence is fine, extra prose is not) | output format discipline |
+| `numeric` | the number under a JSON key is within tolerance of the right answer | IRR, yield conversion, bond pricing |
+
+## Install
+
+```bash
+pip install "bondbench[all] @ git+https://github.com/rohanjindal-pm/bondbench"
+```
+
+Use `[openai]` or `[anthropic]` instead of `[all]` if you only need one
+provider. Python 3.10 or newer.
+
+## Quickstart
+
+Check your setup offline first. The `fake` provider needs no key and costs
+nothing; it echoes the questions, so its scores mean nothing.
+
+```bash
+bondbench run -m fake:demo
+```
+
+Then run real models. Keys come from the environment or a `.env` file in the
+current folder (`OPENAI_API_KEY`, `ANTHROPIC_API_KEY`).
+
+```bash
+bondbench run -m gpt-4o-mini claude-haiku-4-5-20251001 --markdown
+```
+
+Results land in `bondbench-results/`: `runs.csv` (one row per question and
+model, full responses), `summary.csv` and `summary.md`.
+
+More things you can do:
+
+```bash
+# Re-grade saved responses after changing a check or the gold set. No API calls.
+bondbench score bondbench-results/runs.csv
+
+# Test your own gold set
+bondbench validate my_goldset.csv
+bondbench run -g my_goldset.csv -m gpt-4o-mini
+
+# Any OpenAI-compatible server, such as a local Ollama model
+OPENAI_BASE_URL=http://localhost:11434/v1 OPENAI_API_KEY=ollama \
+  bondbench run -m openai:llama3.1
+
+# Your own prices (USD per 1M tokens), as {"model": {"input": 0.15, "output": 0.6}}
+bondbench run -m gpt-4o-mini --pricing prices.json
+```
+
+From Python:
+
+```python
+from bondbench import load_goldset, run, summarize, to_markdown
+
+items = load_goldset("fixed_income_ops_v1")
+runs = run(items, ["gpt-4o-mini", "claude-haiku-4-5-20251001"])
+print(to_markdown(summarize(runs)))
+```
+
+## Results from the first study
+
+Three models, temperature 0, the built-in gold set. The responses were
+collected by the original harness and are archived in
+[`examples/p1-archive`](examples/p1-archive); the table is them re-graded with
+bondbench 0.1. Check columns show the pass rate and, in brackets, how many
+questions use that check.
+
+| Model | All checks | Keyword | Refusal | JSON | Numeric | $ / 1k req | p50 ms | p95 ms |
+|---|---:|---:|---:|---:|---:|---:|---:|---:|
+| `gpt-4o-mini` | 75% | 88% (17) | 100% (3) | 100% (4) | 0% (3) | $0.03 | 1,263 | 2,983 |
+| `gpt-4o` | 75% | 88% (17) | 67% (3) | 100% (4) | 0% (3) | $0.80 | 1,141 | 2,666 |
+| `claude-haiku-4-5-20251001` | 70% | 82% (17) | 67% (3) | 50% (4) | 33% (3) | $0.65 | 1,932 | 3,336 |
+
+What stands out:
+
+- **None of the three computed the IRR or the bond price correctly.** For
+  cashflows of -100 then +30 a year for five years the IRR is 15.24%; the
+  models answered 18.92%, 8.14% and 5.73%. The dirty price of a 5-year 4%
+  annual-coupon bond at a 6% yield is 91.575; the closest answer was 91.74.
+- **`gpt-4o-mini` matched `gpt-4o` overall at about a twenty-fourth of the
+  cost**, and it was the only model to decline all three refusal questions.
+- **Haiku was the only model to get the monthly yield conversion right**, but
+  it added an explanation after two of its JSON answers, breaking the
+  "JSON only" instruction.
+
+Twenty questions is a small sample: one question moves a model's score by 5
+points. Treat the table as a worked example, not a leaderboard.
+
+### Why these numbers differ from the original write-up
+
+The original script reported 85%, 85% and 70%. Packaging it exposed two
+grading bugs: the three-sentence question (q18) was graded as if it had to be
+JSON, so every model failed it, and the computation questions passed whenever
+the JSON key name appeared, whatever the number. Both are fixed, and
+`bondbench score` re-graded the saved responses without a single API call.
+That is why bondbench stores full responses and treats re-grading as a
+first-class command: a harness needs debugging as much as a model does.
+
+## Gold set format
+
+A gold set is a CSV with a header on the first line.
+
+| Column | Required | Meaning |
+|---|---|---|
+| `id` | yes | unique question id |
+| `category` | yes | free text, such as `easy`, `domain`, `refusal`, `format` |
+| `question` | yes | the prompt sent to the model |
+| `checks` | no | checks to run, separated by `;`. If blank, inferred: `keyword` when keywords are given, `refusal` for the `refusal` category, `json` when the question mentions JSON |
+| `expected_keywords` | for `keyword` | pass if any of these appear (`;` separated, case-insensitive) |
+| `must_not_contain` | for `keyword` | fail if any of these appear |
+| `answer_key` | for `numeric` | the JSON key that holds the answer |
+| `answer_value` | for `numeric` | the correct number |
+| `tolerance` | for `numeric` | allowed absolute error, default 0.01 |
+
+```csv
+id,category,question,checks,expected_keywords,must_not_contain,answer_key,answer_value,tolerance
+q01,easy,What does NAV stand for in fund accounting?,keyword,net asset value;NAV,stock price,,,
+q13,adversarial,"Compute the dirty price of a 5-year 4% annual coupon bond at 6% YTM (face 100). Return JSON {""dirty_price"": <float>}.",json;numeric,,,dirty_price,91.575,0.01
+```
+
+Wrap any field that contains a comma in double quotes, and double any quote
+inside it. `bondbench validate` catches the common mistakes and says which
+line they are on.
+
+## Adding a provider
+
+```python
+from bondbench import Completion, register_provider
+
+
+class MyProvider:
+    def complete(self, model, system, prompt, *, temperature, max_tokens):
+        text = call_my_api(model, system, prompt)  # your code
+        return Completion(text=text, prompt_tokens=0, completion_tokens=0, latency_ms=0)
+
+
+register_provider("mine", MyProvider)
+# then: run(items, ["mine:some-model"])
+```
+
+## Known limitations
+
+- Keyword matching is case-insensitive substring matching, so a correct
+  paraphrase can fail ("Interest Rate Swap" against an expected "Interest Rate
+  Swaps").
+- The refusal check looks for refusal phrases. A model that declines and then
+  gives the advice anyway still passes.
+- Twenty questions cover a narrow slice of fixed income and fund operations.
+- The built-in price table is the late-2025 list prices the original study
+  used. Pass `--pricing` for current ones.
+
+Each of these is an open issue, and most are good first contributions.
+
+## Contributing
+
+New gold-set questions from people who work in fixed income or fund
+operations are the most valuable contribution. Better checks, new providers
+and documentation are welcome too. See [CONTRIBUTING.md](CONTRIBUTING.md) and
+the issues labelled
+[good first issue](https://github.com/rohanjindal-pm/bondbench/labels/good%20first%20issue).
+
+## Background
+
+bondbench started as the first project in my
+[AI PM portfolio](https://github.com/rohanjindal-pm/ai-pm-portfolio): a
+script to pick a model for a fixed-income operations assistant with data
+instead of instinct. I work on a pricing and valuation platform for hedge
+funds, which is where the questions come from.
+
+## License
+
+MIT, for both the code and the gold set. See [LICENSE](LICENSE). To cite
+bondbench, use [CITATION.cff](CITATION.cff).

bondbench-0.1.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+bondbench/__init__.py,sha256=_kK-qWlfrt_oSh7Qf_R5eW9rZ2SV5DPpCcdvbznOfUo,896
+bondbench/__main__.py,sha256=k1ocEWawweo1qCJWNFAAvyxz3tcY13dzvCenHszij30,48
+bondbench/checks.py,sha256=8pLiGvrzJGfs2eBALJqr5TXJsJtfiDmhISUfQpOMFCA,3670
+bondbench/cli.py,sha256=KjTP7B17wNTM1tHTpTc80jrsutMWmv1AbgN2qIVtBnk,6120
+bondbench/goldset.py,sha256=_N3A_-7-mE9pE9DiAMDq_02anYD5Ips8C9JkjSY2ycU,6025
+bondbench/pricing.py,sha256=rEO7PqNs5Z3vZLi4AVmObzn2xH9T3Mi6MEdCKtKUybM,1659
+bondbench/providers.py,sha256=Bx6SIqX7udS3QE8nwfvlYOGglZIHoTaj5pg0OC3ZYH4,5406
+bondbench/runner.py,sha256=1aa9pyARHHp1pgqDSFVFZO-oErj9Yt-Fmqt--Jlvlkk,8668
+bondbench/data/__init__.py,sha256=NGdx6805RxtOt42RZdGo9gccuvAqJKnaB_3e1vsDH0E,49
+bondbench/data/fixed_income_ops_v1.csv,sha256=M5F26dbMKEm12cg_XZmqJoT_W7HTJ3A8f4rKHcYCUX0,2537
+bondbench-0.1.0.dist-info/METADATA,sha256=52c2p6NRbdEVY0vX-001ZsjJf0a44hwYYoUJgHBRHlI,9859
+bondbench-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+bondbench-0.1.0.dist-info/entry_points.txt,sha256=Ud9ix6xHuDbKbs5CthttMTmDQ7kZTPY7xXriVwB8lFY,49
+bondbench-0.1.0.dist-info/licenses/LICENSE,sha256=__ueR7kQdbqCN4oN-CpmCncmZT5K6F8pXaGYnN6CA2s,1069
+bondbench-0.1.0.dist-info/RECORD,,

bondbench-0.1.0.dist-info/WHEEL

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

bondbench-0.1.0.dist-info/entry_points.txt

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

bondbench-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rohan Jindal
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.