openchainbench 0.1.0__py3-none-any.whl

openchainbench/__init__.py

@@ -0,0 +1,48 @@
+"""Official Python client for OpenChainBench.
+
+OpenChainBench (https://openchainbench.com) publishes live, reproducible
+benchmarks of crypto infrastructure: RPC latency, bridge fees, perp venue
+performance, oracle deviation, and more. This package wraps the public,
+CC-BY-4.0 licensed JSON API so that Python applications, notebooks, and
+agents can cite live numbers without scraping HTML.
+"""
+
+from .client import DEFAULT_BASE_URL, OpenChainBench
+from .exceptions import (
+    APIUnavailableError,
+    NotFoundError,
+    OpenChainBenchError,
+    RateLimitError,
+)
+from .models import (
+    Benchmark,
+    BenchmarkSummary,
+    CitableIndex,
+    Latency,
+    Leader,
+    ProviderResult,
+    Series,
+    SeriesProvider,
+    Source,
+)
+
+__version__ = "0.1.0"
+
+__all__ = [
+    "DEFAULT_BASE_URL",
+    "OpenChainBench",
+    "OpenChainBenchError",
+    "NotFoundError",
+    "RateLimitError",
+    "APIUnavailableError",
+    "Benchmark",
+    "BenchmarkSummary",
+    "CitableIndex",
+    "Latency",
+    "Leader",
+    "ProviderResult",
+    "Series",
+    "SeriesProvider",
+    "Source",
+    "__version__",
+]

openchainbench/client.py

@@ -0,0 +1,202 @@
+"""Synchronous HTTP client for the public OpenChainBench API.
+
+Wraps three endpoints:
+
+* ``GET /api/citable`` -> :meth:`OpenChainBench.list_benchmarks`
+* ``GET /api/stat/<slug>`` -> :meth:`OpenChainBench.get_benchmark`
+* ``GET /api/series/<slug>?range=...`` -> :meth:`OpenChainBench.get_series`
+
+The client keeps a long-lived ``httpx.Client`` and supports the context
+manager protocol. Errors are mapped to a typed hierarchy in
+:mod:`openchainbench.exceptions` so callers can ``except`` on intent rather
+than HTTP status codes.
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Optional
+
+import httpx
+
+from .exceptions import (
+    APIUnavailableError,
+    NotFoundError,
+    OpenChainBenchError,
+    RateLimitError,
+)
+from .models import Benchmark, BenchmarkSummary, CitableIndex, Series
+
+DEFAULT_BASE_URL = "https://openchainbench.com"
+DEFAULT_TIMEOUT = 30.0
+USER_AGENT = "openchainbench-python/0.1.0"
+
+_SUPPORTED_RANGES = ("24h", "7d", "30d")
+
+
+def _parse_retry_after(value: Optional[str]) -> Optional[int]:
+    if not value:
+        return None
+    try:
+        return int(value)
+    except (TypeError, ValueError):
+        return None
+
+
+def _raise_for_status(response: httpx.Response) -> None:
+    if response.status_code < 400:
+        return
+
+    body: Any
+    try:
+        body = response.json()
+    except ValueError:
+        body = {}
+
+    message = (
+        body.get("error")
+        if isinstance(body, dict) and body.get("error")
+        else f"HTTP {response.status_code} from {response.request.url}"
+    )
+
+    if response.status_code == 404:
+        raise NotFoundError(str(message))
+    if response.status_code == 429:
+        retry = _parse_retry_after(response.headers.get("retry-after"))
+        if retry is None and isinstance(body, dict):
+            retry = body.get("retryAfterSec")
+        raise RateLimitError(str(message), retry_after_sec=retry)
+    if response.status_code == 503:
+        retry = _parse_retry_after(response.headers.get("retry-after"))
+        if retry is None and isinstance(body, dict):
+            retry = body.get("retryAfterSec")
+        raise APIUnavailableError(str(message), retry_after_sec=retry)
+
+    raise OpenChainBenchError(str(message), status_code=response.status_code)
+
+
+class OpenChainBench:
+    """Synchronous client for openchainbench.com.
+
+    Example:
+        >>> from openchainbench import OpenChainBench
+        >>> with OpenChainBench() as ocb:
+        ...     for bench in ocb.list_benchmarks():
+        ...         print(bench.slug, bench.value)
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        *,
+        timeout: float = DEFAULT_TIMEOUT,
+        user_agent: str = USER_AGENT,
+        client: Optional[httpx.Client] = None,
+    ) -> None:
+        self._owns_client = client is None
+        self._client = client or httpx.Client(
+            base_url=base_url.rstrip("/"),
+            timeout=timeout,
+            headers={
+                "User-Agent": user_agent,
+                "Accept": "application/json",
+            },
+        )
+
+    def list_benchmarks(self) -> List[BenchmarkSummary]:
+        """Return every live benchmark with its current headline figure.
+
+        Wraps the ``CitableIndex`` envelope and returns the list directly
+        for ergonomic iteration. Use :meth:`fetch_citable_index` if you
+        need the site metadata as well.
+        """
+        return list(self.fetch_citable_index().benchmarks)
+
+    def fetch_citable_index(self) -> CitableIndex:
+        """Return the full ``/api/citable`` payload including site metadata."""
+        data = self._get("/api/citable")
+        return CitableIndex.from_dict(data)
+
+    def get_benchmark(
+        self,
+        slug: str,
+        *,
+        chain: Optional[str] = None,
+        region: Optional[str] = None,
+    ) -> Benchmark:
+        """Return the full benchmark detail.
+
+        Args:
+            slug: Benchmark slug, e.g. ``"bridge-fee"``.
+            chain: Optional chain filter (e.g. ``"ethereum"``).
+            region: Optional region filter (e.g. ``"eu-west"``).
+
+        Raises:
+            NotFoundError: The slug does not exist or is not live.
+        """
+        params: dict[str, str] = {}
+        if chain:
+            params["chain"] = chain
+        if region:
+            params["region"] = region
+        data = self._get(f"/api/stat/{slug}", params=params or None)
+        return Benchmark.from_dict(data)
+
+    def get_series(
+        self,
+        slug: str,
+        *,
+        range: str = "24h",
+        chain: Optional[str] = None,
+        region: Optional[str] = None,
+        providers: Optional[List[str]] = None,
+    ) -> Series:
+        """Return the per-provider time series for a benchmark.
+
+        Args:
+            slug: Benchmark slug.
+            range: One of ``"24h"``, ``"7d"``, ``"30d"``.
+            chain: Optional chain filter.
+            region: Optional region filter.
+            providers: Optional list of provider slugs to restrict the result to.
+
+        Raises:
+            ValueError: ``range`` is not supported.
+            NotFoundError: The slug does not exist or has no data for ``range``.
+        """
+        if range not in _SUPPORTED_RANGES:
+            raise ValueError(
+                f"range must be one of {_SUPPORTED_RANGES}, got {range!r}"
+            )
+        params: dict[str, str] = {"range": range}
+        if chain:
+            params["chain"] = chain
+        if region:
+            params["region"] = region
+        if providers:
+            params["providers"] = ",".join(providers)
+        data = self._get(f"/api/series/{slug}", params=params)
+        return Series.from_dict(data)
+
+    def close(self) -> None:
+        """Close the underlying HTTP client (if owned)."""
+        if self._owns_client:
+            self._client.close()
+
+    def __enter__(self) -> "OpenChainBench":
+        return self
+
+    def __exit__(self, *exc_info: Any) -> None:
+        self.close()
+
+    def _get(self, path: str, *, params: Optional[dict[str, str]] = None) -> Any:
+        try:
+            response = self._client.get(path, params=params)
+        except httpx.HTTPError as exc:
+            raise OpenChainBenchError(f"HTTP request failed: {exc}") from exc
+        _raise_for_status(response)
+        try:
+            return response.json()
+        except ValueError as exc:
+            raise OpenChainBenchError(
+                f"Response was not valid JSON: {exc}"
+            ) from exc

openchainbench/exceptions.py

@@ -0,0 +1,41 @@
+"""Exception hierarchy for the OpenChainBench client."""
+
+from __future__ import annotations
+
+from typing import Optional
+
+
+class OpenChainBenchError(Exception):
+    """Base error for every failure surfaced by this client."""
+
+    def __init__(self, message: str, *, status_code: Optional[int] = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+
+class NotFoundError(OpenChainBenchError):
+    """Raised when a benchmark slug or range does not exist."""
+
+    def __init__(self, message: str) -> None:
+        super().__init__(message, status_code=404)
+
+
+class RateLimitError(OpenChainBenchError):
+    """Raised when the API returns HTTP 429.
+
+    Attributes:
+        retry_after_sec: Seconds the caller should wait before retrying,
+            parsed from the ``Retry-After`` header or the response body.
+    """
+
+    def __init__(self, message: str, *, retry_after_sec: Optional[int] = None) -> None:
+        super().__init__(message, status_code=429)
+        self.retry_after_sec = retry_after_sec
+
+
+class APIUnavailableError(OpenChainBenchError):
+    """Raised when the API returns HTTP 503 (no live snapshot available)."""
+
+    def __init__(self, message: str, *, retry_after_sec: Optional[int] = None) -> None:
+        super().__init__(message, status_code=503)
+        self.retry_after_sec = retry_after_sec

openchainbench/models.py

@@ -0,0 +1,319 @@
+"""Dataclass models that mirror the public OpenChainBench API payloads.
+
+Every model is ``frozen=True`` so instances are safe to share across threads
+and cache. Parsing is permissive on unknown fields (the API may add new keys
+without bumping a version), but strict on the fields the client documents.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Mapping, Optional, Sequence
+
+
+def _opt_float(value: Any) -> Optional[float]:
+    if value is None:
+        return None
+    return float(value)
+
+
+def _opt_int(value: Any) -> Optional[int]:
+    if value is None:
+        return None
+    return int(value)
+
+
+def _opt_str(value: Any) -> Optional[str]:
+    if value is None:
+        return None
+    return str(value)
+
+
+def _methodology(value: Any) -> tuple[str, ...]:
+    """Methodology can arrive as a list of bullet strings or as a single
+    paragraph. Normalize to a tuple of non-empty strings either way."""
+    if value is None:
+        return ()
+    if isinstance(value, str):
+        return (value,) if value else ()
+    if isinstance(value, Sequence):
+        return tuple(str(item) for item in value if item)
+    return (str(value),)
+
+
+@dataclass(frozen=True)
+class Leader:
+    """The current top provider for a benchmark."""
+
+    name: str
+    slug: str
+    value: float
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "Leader":
+        return cls(
+            name=str(data["name"]),
+            slug=str(data["slug"]),
+            value=float(data["value"]),
+        )
+
+
+@dataclass(frozen=True)
+class Source:
+    """Editorial source attribution for a benchmark.
+
+    The API surfaces ``source`` either as an object (``{type,url,label}``)
+    or as a bare URL string for benches whose only attribution is a link.
+    Both shapes parse into this dataclass.
+    """
+
+    type: Optional[str] = None
+    url: Optional[str] = None
+    label: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Any) -> Optional["Source"]:
+        if data is None:
+            return None
+        if isinstance(data, str):
+            return cls(url=data)
+        if isinstance(data, Mapping):
+            return cls(
+                type=_opt_str(data.get("type")),
+                url=_opt_str(data.get("url")),
+                label=_opt_str(data.get("label")),
+            )
+        return None
+
+
+@dataclass(frozen=True)
+class BenchmarkSummary:
+    """One row from ``GET /api/citable``.
+
+    The summary is intentionally flat so it can be consumed without
+    follow-up calls. ``value`` and ``leader`` are ``None`` when the bench
+    is in the ``insufficient`` state (live spec, no usable sample yet).
+    """
+
+    slug: str
+    title: str
+    category: str
+    metric: str
+    unit: str
+    status: str
+    value: Optional[float]
+    leader: Optional[Leader]
+    sample_size: int
+    as_of: Optional[str]
+    headline: Optional[str]
+    url: str
+    api_url: str
+    og_image: Optional[str]
+    source: Optional[Source]
+    license: str
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "BenchmarkSummary":
+        leader = data.get("leader")
+        return cls(
+            slug=str(data["slug"]),
+            title=str(data["title"]),
+            category=str(data["category"]),
+            metric=str(data["metric"]),
+            unit=str(data["unit"]),
+            status=str(data["status"]),
+            value=_opt_float(data.get("value")),
+            leader=Leader.from_dict(leader) if leader else None,
+            sample_size=int(data.get("sampleSize", 0) or 0),
+            as_of=_opt_str(data.get("asOf")),
+            headline=_opt_str(data.get("headline")),
+            url=str(data.get("url", "")),
+            api_url=str(data.get("api", "")),
+            og_image=_opt_str(data.get("ogImage")),
+            source=Source.from_dict(data.get("source")),
+            license=str(data.get("license", "CC-BY-4.0")),
+        )
+
+
+@dataclass(frozen=True)
+class Latency:
+    """Percentile breakdown for a provider result. Fields can be ``None``
+    when the benchmark is in the ``insufficient`` state."""
+
+    p50: Optional[float]
+    p90: Optional[float]
+    p99: Optional[float]
+    mean: Optional[float]
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "Latency":
+        return cls(
+            p50=_opt_float(data.get("p50")),
+            p90=_opt_float(data.get("p90")),
+            p99=_opt_float(data.get("p99")),
+            mean=_opt_float(data.get("mean")),
+        )
+
+
+@dataclass(frozen=True)
+class ProviderResult:
+    """One ranked provider inside a benchmark."""
+
+    name: str
+    slug: str
+    type: Optional[str]
+    layer: Optional[str]
+    tag: Optional[str]
+    ms: Latency
+    success_rate: Optional[float]
+    sample_size: Optional[int]
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "ProviderResult":
+        return cls(
+            name=str(data["name"]),
+            slug=str(data["slug"]),
+            type=_opt_str(data.get("type")),
+            layer=_opt_str(data.get("layer")),
+            tag=_opt_str(data.get("tag")),
+            ms=Latency.from_dict(data.get("ms") or {}),
+            success_rate=_opt_float(data.get("successRate")),
+            sample_size=_opt_int(data.get("sampleSize")),
+        )
+
+
+@dataclass(frozen=True)
+class Benchmark:
+    """Full payload returned by ``GET /api/stat/<slug>``."""
+
+    slug: str
+    title: str
+    subtitle: Optional[str]
+    category: str
+    metric: str
+    unit: str
+    status: str
+    higher_is_better: bool
+    value: Optional[float]
+    leader: Optional[Leader]
+    rankings: Sequence[ProviderResult]
+    sparkline: Sequence[float]
+    sample_size: int
+    as_of: Optional[str]
+    headline: Optional[str]
+    quote: Optional[str]
+    page_url: str
+    og_image: Optional[str]
+    source: Optional[Source]
+    methodology: Sequence[str]
+    license: str
+    best_per_chain: Optional[Mapping[str, Any]]
+    worst_per_chain: Optional[Mapping[str, Any]]
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "Benchmark":
+        leader = data.get("leader")
+        rankings = [ProviderResult.from_dict(r) for r in data.get("rankings", []) or []]
+        sparkline = [float(v) for v in (data.get("sparkline") or []) if v is not None]
+        return cls(
+            slug=str(data["slug"]),
+            title=str(data["title"]),
+            subtitle=_opt_str(data.get("subtitle")),
+            category=str(data["category"]),
+            metric=str(data["metric"]),
+            unit=str(data["unit"]),
+            status=str(data["status"]),
+            higher_is_better=bool(data.get("higherIsBetter", False)),
+            value=_opt_float(data.get("value")),
+            leader=Leader.from_dict(leader) if leader else None,
+            rankings=tuple(rankings),
+            sparkline=tuple(sparkline),
+            sample_size=int(data.get("sampleSize", 0) or 0),
+            as_of=_opt_str(data.get("asOf")),
+            headline=_opt_str(data.get("headline")),
+            quote=_opt_str(data.get("quote")),
+            page_url=str(data.get("pageUrl", "")),
+            og_image=_opt_str(data.get("ogImage")),
+            source=Source.from_dict(data.get("source")),
+            methodology=_methodology(data.get("methodology")),
+            license=str(data.get("license", "CC-BY-4.0")),
+            best_per_chain=data.get("bestPerChain"),
+            worst_per_chain=data.get("worstPerChain"),
+        )
+
+
+@dataclass(frozen=True)
+class SeriesProvider:
+    """One provider trace inside a ``Series``."""
+
+    slug: str
+    name: str
+    color: str
+    values: Sequence[float]
+    logo: Optional[str] = None
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "SeriesProvider":
+        values = [float(v) for v in (data.get("values") or []) if v is not None]
+        return cls(
+            slug=str(data["slug"]),
+            name=str(data["name"]),
+            color=str(data.get("color", "#7f7f7f")),
+            values=tuple(values),
+            logo=_opt_str(data.get("logo")),
+        )
+
+
+@dataclass(frozen=True)
+class Series:
+    """Payload returned by ``GET /api/series/<slug>``.
+
+    ``timestamps`` and each provider's ``values`` are index-aligned.
+    """
+
+    slug: str
+    title: str
+    metric: str
+    unit: str
+    higher_is_better: bool
+    range: str
+    timestamps: Sequence[int]
+    providers: Sequence[SeriesProvider] = field(default_factory=tuple)
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "Series":
+        return cls(
+            slug=str(data["slug"]),
+            title=str(data["title"]),
+            metric=str(data["metric"]),
+            unit=str(data["unit"]),
+            higher_is_better=bool(data.get("higherIsBetter", False)),
+            range=str(data["range"]),
+            timestamps=tuple(int(t) for t in (data.get("timestamps") or [])),
+            providers=tuple(
+                SeriesProvider.from_dict(p) for p in (data.get("providers") or [])
+            ),
+        )
+
+
+@dataclass(frozen=True)
+class CitableIndex:
+    """Top-level payload returned by ``GET /api/citable``."""
+
+    site_name: str
+    site_url: str
+    license: str
+    count: int
+    benchmarks: Sequence[BenchmarkSummary]
+
+    @classmethod
+    def from_dict(cls, data: Mapping[str, Any]) -> "CitableIndex":
+        site = data.get("site") or {}
+        benches = [BenchmarkSummary.from_dict(b) for b in data.get("benchmarks", [])]
+        return cls(
+            site_name=str(site.get("name", "OpenChainBench")),
+            site_url=str(site.get("url", "https://openchainbench.com")),
+            license=str(site.get("license", "CC-BY-4.0")),
+            count=int(data.get("count", len(benches))),
+            benchmarks=tuple(benches),
+        )

openchainbench-0.1.0.dist-info/METADATA

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: openchainbench
+Version: 0.1.0
+Summary: Python client for OpenChainBench live crypto infrastructure benchmarks
+Project-URL: Homepage, https://openchainbench.com
+Project-URL: Documentation, https://openchainbench.com/docs
+Project-URL: Repository, https://github.com/ChainBench/OpenChainBench
+Project-URL: Issues, https://github.com/ChainBench/OpenChainBench/issues
+Project-URL: Changelog, https://github.com/ChainBench/OpenChainBench/releases
+Author-email: OpenChainBench <hello@openchainbench.com>
+License: MIT
+License-File: LICENSE
+Keywords: benchmark,blockchain,crypto,ethereum,infrastructure,openchainbench,rpc,solana
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+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 :: Internet
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest-cov>=5; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# openchainbench
+
+Official Python client for [OpenChainBench](https://openchainbench.com), the live, reproducible benchmark suite for crypto infrastructure (RPC latency, bridge fees, perp venues, oracle deviation, and more).
+
+[![PyPI version](https://img.shields.io/pypi/v/openchainbench.svg)](https://pypi.org/project/openchainbench/)
+[![Python versions](https://img.shields.io/pypi/pyversions/openchainbench.svg)](https://pypi.org/project/openchainbench/)
+[![Downloads](https://img.shields.io/pypi/dm/openchainbench.svg)](https://pypi.org/project/openchainbench/)
+[![License](https://img.shields.io/pypi/l/openchainbench.svg)](https://github.com/ChainBench/OpenChainBench/blob/main/LICENSE)
+
+The data served by openchainbench.com is published under [CC-BY-4.0](https://creativecommons.org/licenses/by/4.0/). Attribute with a link back to the benchmark page (`pageUrl` on every payload).
+
+## Install
+
+```bash
+pip install openchainbench
+```
+
+Requires Python 3.10+.
+
+## Quick start
+
+```python
+from openchainbench import OpenChainBench
+
+with OpenChainBench() as ocb:
+    for bench in ocb.list_benchmarks():
+        if bench.leader:
+            print(f"{bench.title}: {bench.leader.name} -> {bench.value}")
+```
+
+### Fetch one benchmark
+
+```python
+from openchainbench import OpenChainBench
+
+with OpenChainBench() as ocb:
+    bench = ocb.get_benchmark("bridge-fee")
+    print(bench.headline)
+    for row in bench.rankings[:3]:
+        print(row.slug, row.ms.p50, row.success_rate)
+```
+
+### Fetch a time series
+
+```python
+from openchainbench import OpenChainBench
+
+with OpenChainBench() as ocb:
+    series = ocb.get_series("bridge-fee", range="24h")
+    for provider in series.providers:
+        print(provider.name, provider.values[-1])
+```
+
+### Filter by chain or region
+
+```python
+bench = ocb.get_benchmark("network-fees", chain="ethereum")
+series = ocb.get_series("network-fees", range="7d", chain="ethereum", region="eu-west")
+```
+
+## Error handling
+
+The client maps HTTP responses to a typed exception hierarchy so callers
+can react to intent rather than status codes.
+
+```python
+from openchainbench import (
+    OpenChainBench,
+    NotFoundError,
+    RateLimitError,
+    APIUnavailableError,
+)
+
+with OpenChainBench() as ocb:
+    try:
+        ocb.get_benchmark("not-a-real-slug")
+    except NotFoundError:
+        ...
+    except RateLimitError as exc:
+        print(f"retry after {exc.retry_after_sec}s")
+    except APIUnavailableError:
+        # cold cache or Prom blackout, retry later
+        ...
+```
+
+## API reference
+
+| Method | Endpoint | Returns |
+|---|---|---|
+| `list_benchmarks()` | `GET /api/citable` | `list[BenchmarkSummary]` |
+| `fetch_citable_index()` | `GET /api/citable` | `CitableIndex` |
+| `get_benchmark(slug, *, chain=None, region=None)` | `GET /api/stat/<slug>` | `Benchmark` |
+| `get_series(slug, *, range="24h", chain=None, region=None, providers=None)` | `GET /api/series/<slug>` | `Series` |
+
+All models are immutable dataclasses (`frozen=True`).
+
+## Rate limits
+
+The public API allows 60 requests per minute per IP. The client surfaces
+HTTP 429 as a `RateLimitError` with a `retry_after_sec` attribute.
+
+## Citation
+
+If you use the data in a paper, post, or product, please link the
+benchmark page. The license is CC-BY-4.0. Every payload includes a
+ready-to-paste `quote` field that already contains the attribution.
+
+## Links
+
+- Site: <https://openchainbench.com>
+- Docs: <https://openchainbench.com/docs>
+- Repository: <https://github.com/ChainBench/OpenChainBench>
+- Issues: <https://github.com/ChainBench/OpenChainBench/issues>
+
+## License
+
+MIT. The data fetched from the API stays under CC-BY-4.0; this client
+license only covers the code.

openchainbench-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+openchainbench/__init__.py,sha256=dG4mTaHoFxXIIiVO_PiWzdJ0pFmyvvlh0Fpf45bEhx4,1095
+openchainbench/client.py,sha256=uMaTshp0gJ5S2UfLoDg8yYx1KOOLUMSrpiP3WA2xatk,6469
+openchainbench/exceptions.py,sha256=gk4eKiHtpsGnjFIV6avo6wKJkrKH7FP_doSRG63xFug,1352
+openchainbench/models.py,sha256=1gGMVU1kkkxy499wm2oZhPP9Ck48peFUUZhPThWaywk,9757
+openchainbench/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+openchainbench-0.1.0.dist-info/METADATA,sha256=GqArUpbdl1PvR-jB3eaPrE3OPaKVOlekTD4xdOIC9xs,5228
+openchainbench-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+openchainbench-0.1.0.dist-info/licenses/LICENSE,sha256=lIreIjLnw7yX0656BVlZeGKovyOIa7A6LbFVY53Bx4c,1084
+openchainbench-0.1.0.dist-info/RECORD,,

openchainbench-0.1.0.dist-info/WHEEL

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

openchainbench-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 OpenChainBench contributors
+
+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.