opencode-models 0.1.0__py3-none-any.whl

opencode_models/__init__.py

@@ -0,0 +1,8 @@
+"""Ranked console of AI models: benchmark scores against real per-token prices."""
+
+from importlib.metadata import PackageNotFoundError, version
+
+try:
+    __version__ = version("opencode-models")
+except PackageNotFoundError:  # bare checkout without an install
+    __version__ = "0.0.0+unknown"

opencode_models/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

opencode_models/arena.py

@@ -0,0 +1,108 @@
+"""Arena.ai (LMArena) Elo scores, cached in data/ so every command except the
+online lookups reads locally.
+
+The live arena API is Cloudflare-blocked, so the lookup uses the community
+copy on HuggingFace's datasets-server JSON API (no auth). Results are
+folded into ``data/aiarena/scores.json`` — a {slug: elo} cache — and merged
+into models at load time as an "LMArena Elo" benchmark axis.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from .data import Model
+
+CACHE_NAME = "scores.json"
+ARENA_BENCHMARK = "LMArena Elo"
+ROWS_URL = (
+    "https://datasets-server.huggingface.co/rows?dataset="
+    "openaccess-ai-collective/chatbot-arena-elo-scores&config=default"
+    "&split=train&offset=0&length=100"
+)
+
+
+class ArenaCache:
+    """Persistent {model slug: Elo} cache backed by one JSON file."""
+
+    def __init__(self, data_dir: Path):
+        self.path = Path(data_dir) / CACHE_NAME
+
+    def load(self) -> dict[str, float]:
+        if not self.path.exists():
+            return {}
+        try:
+            data = json.loads(self.path.read_text())
+        except (json.JSONDecodeError, OSError):
+            return {}
+        return data if isinstance(data, dict) else {}
+
+    def save(self, scores: dict[str, float]) -> None:
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self.path.write_text(json.dumps(scores, indent=1, sort_keys=True) + "\n")
+
+
+def lookup_arena_elo(get) -> dict[str, float]:
+    """Fetch {slug: elo} from the datasets-server rows API (paginated).
+
+    *get* is the injected transport (``fetch.http_get`` in production).
+    """
+    scores: dict[str, float] = {}
+    url: str | None = ROWS_URL
+    while url:
+        doc = json.loads(get(url))
+        for row in doc.get("rows", []):
+            r = row.get("row", {})
+            name = r.get("chatbot_name")
+            elo = r.get("elo_score")
+            if name and isinstance(elo, (int, float)):
+                scores[name] = float(elo)
+        url = doc.get("next_page_url")
+    return scores
+
+
+def _match_key(m: Model) -> str:
+    """Arena names are bare model ids (``deepseek-v4-pro``), so match on the
+    last path segment of our ``lab/model`` id, not the lab-qualified slug."""
+    return m.model_id.rsplit("/", 1)[-1]
+
+
+def merge_arena_scores(models: list[Model], arena: dict[str, float]) -> list[Model]:
+    """Attach LMArena Elo to models whose bare model id matches an arena
+    entry.
+
+    Only models that do not already carry an arena score are touched
+    (cache wins), and a missing price does not disqualify the merge — the
+    arena axis is usable for ranking even before pricing is known.
+    """
+    result = []
+    for m in models:
+        key = _match_key(m)
+        if key in arena and ARENA_BENCHMARK not in m.scores:
+            result.append(merge_arena_score(m, arena[key]))
+        else:
+            result.append(m)
+    return result
+
+
+def merge_arena_score(m: Model, elo: float) -> Model:
+    """Return a copy of *m* with the arena score attached."""
+    scores = dict(m.scores)
+    scores[ARENA_BENCHMARK] = elo
+    return Model(
+        model_id=m.model_id,
+        name=m.name,
+        lab=m.lab,
+        price_input=m.price_input,
+        price_output=m.price_output,
+        price_cached_input=m.price_cached_input,
+        scores=scores,
+        sources=dict(m.sources),
+    )
+
+
+def merge_from_file(models: list[Model], data_dir: Path) -> list[Model]:
+    """Model list with any cached arena scores applied."""
+    cache = ArenaCache(data_dir)
+    return merge_arena_scores(models, cache.load())

opencode_models/auth.py

@@ -0,0 +1,48 @@
+"""Local storage for the Console service-account key.
+
+The key lives in one file under the user's config dir, readable only by
+its owner — never in the repo, never in a data dir (a `--data` checkout
+may be shared or committed). The environment always wins: CI and one-off
+runs set `OPENCODE_API_KEY` without touching the file.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+
+def key_file() -> Path:
+    """Where the saved key lives (XDG config home, per user)."""
+    base = os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config"
+    return Path(base) / "opencode-models" / "api_key"
+
+
+def save_key(key: str) -> Path:
+    """Write *key* to the key file, owner-only, creating dirs as needed.
+
+    The file is created with 0o600 and an existing file is tightened to
+    it — whatever the umask says.
+    """
+    path = key_file()
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
+    with os.fdopen(fd, "w") as handle:
+        handle.write(key)
+    os.chmod(path, 0o600)
+    return path
+
+
+def load_key() -> str | None:
+    """The service-account key: the environment first, then the file.
+
+    None when neither has one. The file's content is stripped — a
+    trailing newline from an editor is not part of the key.
+    """
+    env = os.environ.get("OPENCODE_API_KEY")
+    if env:
+        return env
+    try:
+        return key_file().read_text().strip() or None
+    except OSError:
+        return None

opencode_models/availability.py

@@ -0,0 +1,102 @@
+"""Which models the plans actually offer right now.
+
+The membership lists under ``opencode_models/sources/`` are committed text,
+hand-maintained, and they drift in both directions: a model the provider
+unlisted stays in the list, and a newly offered model is missing from it. In
+the live data 13 Go slugs were still being offered to the console after the
+provider's own docs stopped listing them, two of them models we were actively
+trying to benchmark.
+
+``fetch`` already snapshots the tier documentation for prices, and every row
+of that snapshot names the model the provider is offering. That snapshot is
+the availability record, so it is what this module reads: the same source,
+the same refresh, and current by construction.
+
+A tier with no snapshot is *unknown*, not empty. Restricting the console to
+an empty set because nobody has fetched a snapshot would hide everything, and
+the shipped lists are still the best answer available offline - so the
+callers treat unknown as "no restriction" and the console says so.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from . import sources
+from .live import load_live
+
+
+def _snapshot_ids(data_dir: Path, tier: str) -> set[str] | None:
+    """Model ids the provider's tier snapshot lists, or None if unknown."""
+    path = Path(data_dir) / "tier_prices" / f"{tier}_prices.json"
+    if not path.exists():
+        return None
+    try:
+        rows = json.loads(path.read_text())
+    except (json.JSONDecodeError, OSError):
+        return None
+    if not isinstance(rows, list):
+        return None
+    return {
+        row["model_id"] for row in rows if isinstance(row, dict) and row.get("model_id")
+    }
+
+
+def load_available(data_dir: Path) -> dict[str, set[str] | None]:
+    """Model ids each plan offers, by tier; None where there is no snapshot.
+
+    None means "we have not fetched this tier", which is different from an
+    empty set, which means "the plan offers nothing". The live API snapshot
+    wins wherever it exists — it is what the next request is checked
+    against; the docs snapshot stays the offline fallback.
+    """
+    live = load_live(data_dir)
+    tiers = set(sources.available_sources()) | set(live)
+    out = {}
+    for tier in sorted(tiers):
+        ids = live.get(tier)
+        out[tier] = ids if ids is not None else _snapshot_ids(data_dir, tier)
+    return out
+
+
+def available_ids(data_dir: Path) -> set[str] | None:
+    """Every model id any known plan offers, or None if nothing is known."""
+    known = [ids for ids in load_available(data_dir).values() if ids is not None]
+    return set().union(*known) if known else None
+
+
+def offered(model_id: str, ids: set[str]) -> bool:
+    """Whether *model_id* is in the offered set *ids*.
+
+    The tier pages list free variants under their own slug
+    (``step-5-preview-free``) while the catalog carries one model under the
+    base slug (``stepfun/step-5-preview``) — the same reach
+    :func:`sources.members` implements. Exact matching drops such a model
+    from the pool entirely, which is how every free row once vanished from
+    the list view.
+    """
+    slug = model_id.split("/")[-1]
+    return (
+        slug in ids
+        or model_id in ids
+        or f"{slug}-free" in ids
+        or f"{model_id}-free" in ids
+    )
+
+
+def unlisted(data_dir: Path) -> dict[str, set[str]]:
+    """Slugs the shipped lists carry that the provider no longer offers.
+
+    Worth surfacing rather than silently dropping: a model that quietly
+    disappears from a plan is a change the console should report, not one a
+    reader has to notice is missing.
+    """
+    dropped: dict[str, set[str]] = {}
+    for tier, ids in load_available(data_dir).items():
+        if ids is None:
+            continue  # no snapshot: nothing was dropped
+        missing = sources.load_source(tier) - ids
+        if missing:
+            dropped[tier] = missing
+    return dropped

opencode_models/benchmarks.py

@@ -0,0 +1,19 @@
+"""Inventory of benchmarks present in a dataset, for the selector."""
+
+from __future__ import annotations
+
+from collections import Counter
+
+from .data import Model
+
+
+def available(models: list[Model]) -> list[tuple[str, int]]:
+    """Return ``(benchmark, model_count)`` pairs.
+
+    Sorted by coverage (best-covered first), ties broken by name so the
+    listing is stable between runs.
+    """
+    counts: Counter[str] = Counter()
+    for m in models:
+        counts.update(m.scores.keys())
+    return sorted(counts.items(), key=lambda kv: (-kv[1], kv[0]))