opencode-models 0.1.0__py3-none-any.whl

opencode_models/scoring.py

@@ -0,0 +1,230 @@
+"""A model's score, on one scale the whole catalog can be compared on.
+
+The raw benchmarks are not comparable:Terminal-Bench 2.1 runs 25–90,
+Terminal-Bench 4.0 runs 16–65, SWE-bench Verified 35–96. Putting them in one
+column and sorting on the result compares a 4.0 score against a 2.1 score
+and calls the winner the better model.
+
+So each benchmark gets its own 0–100 scale — its best model in this catalog
+is 100, its worst is 0, and the distance between two models is proportionate
+and linear in the raw score — and a model's score is the **median** of the
+scales it has.
+
+The median rather than the mean because models here carry wildly uneven
+coverage: some have one benchmark, some have thirty. An average lets a model
+with one good score outrank a frontier model that was evaluated properly,
+and it makes the number swing as unrelated benchmarks appear. The median
+answers "how does this model typically do", and one bad result cannot bury a
+model that is strong on everything else.
+"""
+
+from __future__ import annotations
+
+from statistics import median
+
+from .data import Model
+from .overrides import TIER_OFFICIAL, source_tier
+
+#: A benchmark every model scored the same on carries no information, so it
+#: normalises to the midpoint rather than to 100.
+NEUTRAL = 50.0
+
+#: How much of a benchmark's numbers must be checkable before they are
+#: allowed to set the ends of its scale.
+#:
+#: The rule that a vendor self-report cannot set the floor exists to stop one
+#: uncited number from compressing everyone else's score. Applied blindly it
+#: causes the opposite fault: on Terminal-Bench 2.1 only 8 of 50 numbers
+#: come from a board, and scaling the axis to those turned it into a
+#: threshold - bounds of 64.3-73.4, so nearly every model clamped to 0 or
+#: 100 and the primary axis stopped discriminating. A scale drawn from a
+#: small minority is a threshold, not a scale, so the ends stand aside until
+#: the checkable numbers are a real share of the field.
+CHECKABLE_SHARE = 0.25
+
+#: How many benchmarks a model needs before its score means anything.
+#:
+#: The median of one number is that number. A model measured on one
+#: benchmark it happens to lead reads as a top model on the strength of a
+#: single result - in the live catalog 26 of 63 scored models have one
+#: benchmark and 6 of the top 9 rows are among them, one of them leading the
+#: whole catalog on a lone Terminal-Bench 4.0 run. Two independent axes is
+#: the smallest amount of evidence that is not one measurement, and it costs
+#: coverage deliberately: a model with one number is unscored, not ranked
+#: last.
+MIN_AXES = 2
+
+#: The benchmarks this tool scores on, as an explicit list.
+#:
+#: Everything else the catalog mentions is context, not signal. The catalog
+#: carries 212 benchmark names, of which 137 are held by one or two models -
+#: a niche evaluation nobody else ran. Counted, they hand a model a hard 0
+#: (the worst of four is 0) and drag its median down: a model resolving 82 on
+#: SWE-bench Verified was landing on 0 because of a 17.7 on SEC-Bench Pro.
+#:
+#: A prefix rule was the obvious way to write this and it was wrong in both
+#: directions. Matching "Terminal-Bench" also swept in "Terminal-Bench Hard",
+#: "-Science" and 3.0, which are separate task sets rather than runs of the
+#: benchmark; matching "SWE-Bench" admitted Lite, Multimodal and
+#: Multilingual. Each of those opens another axis in the scoring equation
+#: while adding no model that could not otherwise be scored: Lite and
+#: Multimodal reach no tier model at all, Multilingual is only ever carried
+#: alongside Verified or Pro, and 3.0 has two. Naming the benchmarks instead
+#: keeps adding one a deliberate act, with a reason attached.
+#:
+#: An older revision is left out as well. Terminal-Bench 2.0 is 2.1 with an
+#: easier, older task set, and a public task set gets trained against: a
+#: vendor can publish a 2.0 number without the model being able to do the
+#: work. Keeping it costs no coverage either - the five tier models whose
+#: only Terminal-Bench run is a 2.0 all carry SWE-bench - so there is
+#: nothing to weigh against it. Elo is left out too: it is preference votes
+#: on chat answers rather than task completion, and no model in the catalog
+#: carries it.
+#:
+#: DeepSWE 1.1 earns its place by being the only thing that pairs with the
+#: rest. It is the broadest benchmark carried by models that hold nothing
+#: else scored - nine of the 25 offered models on a single axis carry it -
+#: so admitting it is what makes those models rankable at all. It is also
+#: the weakest entry on provenance and on signal, and both facts are worth
+#: stating plainly: every one of its 29 numbers is a vendor self-report (no
+#: board runs it), and its rank correlation with Terminal-Bench 2.1 over the
+#: models carrying both is 0.87, so it mostly re-ranks what TB 2.1 already
+#: says rather than adding an independent read. A median over five
+#: benchmarks therefore leans on TB 2.1 twice.
+#:
+#: The bare "DeepSWE" name stays out: it shares no model with "DeepSWE 1.1"
+#: in the catalog, so it is an older revision carrying four models.
+#:
+#: The order is also the order the benchmarks are shown in: the axis the
+#: console ranks on first, then the axes that fill in.
+_TRACKED = (
+    "Terminal-Bench 2.1",
+    "Terminal-Bench 4.0",
+    "SWE-Bench Verified",
+    "SWE-Bench Pro",
+    "DeepSWE 1.1",
+)
+
+
+def _folded(name: str) -> str:
+    """The benchmark name with dashes read as spaces, whatever the registry.
+
+    Two registries spell these both ways ("Terminal-Bench 2.1",
+    "Terminal Bench 2.1") for one benchmark, and they have to land on one
+    scale and in one column rather than in two near-empty ones.
+    """
+    return name.replace("-", " ")
+
+
+_TRACKED_FOLDED = frozenset(_folded(name) for name in _TRACKED)
+
+
+def tracked(name: str) -> bool:
+    """Whether *name* is one of the benchmarks we score on."""
+    return _folded(name) in _TRACKED_FOLDED
+
+
+def canonical(name: str) -> str:
+    """*name* with the dash and space spellings folded into one benchmark.
+
+    Labs spell these both ways - "Terminal-Bench 2.1" and "Terminal Bench 2.1"
+    are one benchmark from two registries - and they belong side by side in
+    one column rather than in two near-empty ones. Untracked names are
+    returned untouched, which is what keeps "Terminal-Bench-Science 0.1" out
+    of Terminal-Bench's column.
+    """
+    return _folded(name) if tracked(name) else name
+
+
+def scales(models: list[Model]) -> dict[str, tuple[float, float]]:
+    """The 0-100 range of each tracked benchmark, ``(lowest, best)``.
+
+    Over the models that actually carry it: the best model in this catalog
+    is 100 and the lowest is 0, so the ends move when the catalog does.
+
+    The ends are set by numbers someone else can check - an official board
+    or an independent evaluator - and not by vendor self-reports. Min-max is
+    only as good as its extremes: with every number counted, one uncited
+    1.5 from a launch post was the floor of the Terminal-Bench 4.0 scale, so
+    64.85 at the top and 1.5 at the bottom stretched the range and
+    compressed every model's derived score into the middle. A benchmark with
+    no board or independent number at all keeps its own ends, since
+    tightening them would leave those models scored against nothing.
+
+    A benchmark is keyed by its own name, but its bounds are pooled across
+    the spellings registries use for it - one benchmark means one scale, so
+    a model measured by one registry is not the worst of a pair with a model
+    measured by another.
+    """
+    all_values: dict[str, list[float]] = {}
+    checkable: dict[str, list[float]] = {}
+    names: set[str] = set()
+    for model in models:
+        for name, value in model.scores.items():
+            if not (tracked(name) and isinstance(value, (int, float))):
+                continue
+            key = canonical(name)
+            names.add(name)
+            all_values.setdefault(key, []).append(float(value))
+            if source_tier(model.sources.get(name)) <= TIER_OFFICIAL:
+                checkable.setdefault(key, []).append(float(value))
+    tight = {
+        key: (min(values), max(values))
+        for key, values in checkable.items()
+        if len(values) >= CHECKABLE_SHARE * len(all_values[key])
+    }
+    bounds = {
+        key: tight.get(key) or (min(values), max(values))
+        for key, values in all_values.items()
+    }
+    return {name: bounds[canonical(name)] for name in sorted(names)}
+
+
+def normalise(score: float, bounds: tuple[float, float]) -> float:
+    """One raw score onto its benchmark's 0–100 scale.
+
+    Linear and clamped: a score outside the catalog's range — a benchmark
+    fetched after the snapshot, a vendor's own figure — reads 0 or 100
+    rather than extrapolating past the ends.
+    """
+    floor, ceiling = bounds
+    if ceiling <= floor:
+        return NEUTRAL
+    pct = (score - floor) / (ceiling - floor) * 100.0
+    return min(100.0, max(0.0, pct))
+
+
+def derived_scores(
+    model: Model, table: dict[str, tuple[float, float]]
+) -> dict[str, float]:
+    """Each benchmark we score on that this model carries, on its 0–100 scale.
+
+    Benchmarks outside the shortlist never appear: they are not in *table*,
+    which ``scales`` builds from ``_TRACKED`` alone. A benchmark with no
+    spread across the catalog is left out too - it cannot say anything about
+    the model, and counting it at the midpoint would pull a real median
+    toward the middle for no reason.
+    """
+    return {
+        name: normalise(value, bounds)
+        for name, value in model.scores.items()
+        if name in table
+        and isinstance(value, (int, float))
+        and (bounds := table[name])[1] > bounds[0]
+    }
+
+
+def combined(derived: dict[str, float]) -> float | None:
+    """The model's score: the median of its derived scores, or None.
+
+    None below ``MIN_AXES``, which is what makes a thinly measured model
+    unranked rather than ranked on one number.
+    """
+    if len(derived) < MIN_AXES:
+        return None
+    return median(derived.values())
+
+
+def score_of(model: Model, table: dict[str, tuple[float, float]]) -> float | None:
+    """:func:`combined` of :func:`derived_scores`, in one call."""
+    return combined(derived_scores(model, table))

opencode_models/seed.py

@@ -0,0 +1,184 @@
+"""Seed a reference dataset on install, and deploy pushed curation.
+
+A fresh `uv tool install` leaves the XDG data dir empty (or stale from an
+older fetch): the catalog lives in no branch at all, and a bare
+`opencode-models list` then silently disagrees with `just run list`. Seeding
+copies reference files into the target directory for files that are
+*missing* only - an existing file is never overwritten, so a workspace's
+own fetch results are always safe.
+
+`data/overrides/` plays by a different rule on purpose: it is versioned
+curation, not fetched records, so installing newer code must bring newer
+pins. Same-named override files sync from the reference (the target's stale
+pin is the bug being fixed); local files the reference never shipped are
+left alone, and fetched layers stay missing-only whatever happens.
+
+Reference precedence per file: the repo working tree first, then the
+`local-data` branch. The branch is read with `ls-tree`/`show`, so the
+checkout is never switched.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+#: Data subdirectories worth seeding. Everything fetched belongs here;
+#: nothing curated is ever written by `fetch`, so seeding it is safe.
+SEED_SUBDIRS = (
+    "opencode",
+    "tier_prices",
+    "boards",
+    "aiarena",
+    "usage",
+    "available",
+    "overrides",
+)
+
+BRANCH = "local-data"
+PREFIX = "data/"
+
+
+def copy_missing(src: Path, dst: Path) -> tuple[int, int]:
+    """Copy files under *src* to *dst* where *dst* lacks them.
+
+    Returns ``(copied, skipped)``. A missing source is not an error -
+    a fresh clone simply has nothing to seed from.
+    """
+    src, dst = Path(src), Path(dst)
+    if not src.is_dir():
+        return (0, 0)
+    copied = skipped = 0
+    for path in sorted(src.rglob("*")):
+        if not path.is_file():
+            continue
+        dest = dst / path.relative_to(src)
+        if dest.exists():
+            skipped += 1
+            continue
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(path.read_bytes())
+        copied += 1
+    return (copied, skipped)
+
+
+def read_branch_files(repo: Path, branch: str, prefix: str) -> dict[str, str]:
+    """``{path: text}`` for files under *prefix* on *branch*, undecoded raw.
+
+    A missing branch (or a directory that is not a repo at all) reads as
+    empty rather than failing: seeding degrades to the working tree.
+    """
+    try:
+        names = subprocess.run(
+            ["git", "ls-tree", "-r", "--name-only", branch, "--", prefix],
+            cwd=repo,
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout
+    except (subprocess.CalledProcessError, OSError):
+        return {}
+    files: dict[str, str] = {}
+    for name in names.splitlines():
+        name = name.strip()
+        if not name:
+            continue
+        try:
+            text = subprocess.run(
+                ["git", "show", f"{branch}:{name}"],
+                cwd=repo,
+                capture_output=True,
+                check=True,
+            ).stdout
+        except (subprocess.CalledProcessError, OSError):
+            continue
+        files[name] = text.decode("utf-8", errors="replace")
+    return files
+
+
+def sync_tracked(src: Path, dst: Path) -> set[str]:
+    """Deploy curated files, returning the relative names written.
+
+    Same-named files sync (overwrite); local files the reference never
+    shipped are not even listed. Missing source deploys nothing.
+    """
+    src, dst = Path(src), Path(dst)
+    written: set[str] = set()
+    if not src.is_dir():
+        return written
+    for path in sorted(src.rglob("*")):
+        if not path.is_file():
+            continue
+        rel = path.relative_to(src)
+        dest = dst / rel
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        dest.write_bytes(path.read_bytes())
+        written.add(str(rel))
+    return written
+
+
+def seed(target: Path, repo: Path) -> dict[str, int]:
+    """Seed *target* (a data dir) from *repo*.
+
+    Fetched layers copy missing files only; `overrides/` deploys (same-named
+    files sync). Working-tree reference data first, then the branch for
+    whatever the tree lacks. Returns
+    ``{"copied": n, "skipped": m, "synced": k}``.
+    """
+    target, repo = Path(target), Path(repo)
+    copied = skipped = synced = 0
+    for sub in SEED_SUBDIRS:
+        if sub == "overrides":
+            continue
+        c, s = copy_missing(repo / "data" / sub, target / sub)
+        copied += c
+        skipped += s
+    provided = sync_tracked(repo / "data" / "overrides", target / "overrides")
+    synced += len(provided)
+    for key, text in sorted(read_branch_files(repo, BRANCH, PREFIX).items()):
+        rel = key[len(PREFIX) :] if key.startswith(PREFIX) else key
+        dest = target / rel
+        if rel.startswith("overrides/"):
+            if rel[len("overrides/") :] in provided:
+                continue  # the working tree already deployed this pin
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_bytes(text.encode("utf-8"))
+            synced += 1
+        elif dest.exists():
+            skipped += 1
+        else:
+            dest.parent.mkdir(parents=True, exist_ok=True)
+            dest.write_text(text)
+            copied += 1
+    return {"copied": copied, "skipped": skipped, "synced": synced}
+
+
+def _repo_root() -> Path:
+    """The repo this seed runs from: git toplevel, else the cwd."""
+    try:
+        out = subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            capture_output=True,
+            text=True,
+            check=True,
+        ).stdout
+    except (subprocess.CalledProcessError, OSError):
+        return Path.cwd()
+    return Path(out.strip() or ".")
+
+
+def main() -> int:
+    from .cli import default_data_dir
+
+    target = default_data_dir()
+    result = seed(target, _repo_root())
+    print(
+        f"seeded {result['copied']} file(s) and deployed "
+        f"{result['synced']} override(s) into {target} "
+        f"({result['skipped']} already present)"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

opencode_models/sources/go.txt

@@ -0,0 +1,45 @@
+minimax-m3
+minimax-m2.7
+minimax-m2.5
+kimi-k3
+kimi-k2.7-code
+kimi-k2.6
+longcat-2.0
+kimi-k2.5
+glm-5.2
+glm-5.3-flash
+glm-5.3
+glm-5.1
+glm-5
+deepseek-v4-pro
+deepseek-v4-flash
+deepseek-flash
+deepseek-v4.1-flash
+deepseek-v4-flash-vision-exp
+qwen3.7-max
+qwen3.8-max
+qwen3.8-flash
+qwen3.7-plus
+qwen3.6-plus
+qwen3.5-plus
+mimo-v2-pro
+mimo-v2-omni
+mimo-v2.6-pro
+mimo-v2.6-flash
+longcat-2.5-preview-free
+step-5-preview-free
+mimo-v2.5-pro
+mimo-v2.5
+hy4-preview
+hy3
+hy3-preview
+claude-haiku-5-5
+gpt-5.6-luna
+grok-4.5
+grok-4.7
+grok-4.6
+muse-spark-1.3-contributor
+muse-spark-1.2-contributor
+omen-alpha
+gpt-6-luna
+space-bunny

opencode_models/sources/zen.txt

@@ -0,0 +1,87 @@
+claude-fable-5
+claude-fable-5-1
+claude-opus-5-5
+claude-opus-5
+claude-opus-4-8
+claude-opus-4-7
+claude-opus-4-6
+claude-opus-4-5
+claude-sonnet-5-5
+claude-sonnet-5
+claude-sonnet-4-6
+claude-sonnet-4-5
+claude-sonnet-4
+claude-haiku-5-5
+claude-haiku-4-5
+gemini-3.6-flash
+gemini-3.8-flash
+gemini-3.7-flash
+gemini-3.5-flash-lite
+gemini-3.5-flash
+gemini-3.1-pro
+gemini-3-flash
+gpt-6-astra
+gpt-6.1-sol
+gpt-6-sol
+gpt-6-luna
+gpt-5.6-sol
+gpt-5.6-terra
+gpt-5.6-luna
+gpt-5.5
+gpt-5.5-pro
+gpt-5.4
+gpt-5.4-pro
+gpt-5.4-mini
+gpt-5.4-nano
+gpt-5.3-codex-spark
+gpt-5.3-codex
+gpt-5.2
+gpt-5.2-codex
+gpt-5.1
+gpt-5.1-codex-max
+gpt-5.1-codex
+gpt-5.1-codex-mini
+gpt-5
+gpt-5-codex
+gpt-5-nano
+grok-build-0.1
+grok-4.7
+grok-4.6
+grok-4.5
+muse-spark-1.3
+muse-spark-1.2
+mistral-large-4
+deepseek-v4.1-flash
+deepseek-v4-pro
+deepseek-v4-flash
+deepseek-v4-flash-vision-exp
+glm-5.3-flash
+glm-5.3
+glm-5.2
+glm-5.1
+glm-5
+minimax-m3
+minimax-m2.7
+minimax-m2.5
+kimi-k3
+kimi-k2.7-code
+kimi-k2.6
+kimi-k2.5
+qwen3.8-flash
+qwen3.6-plus
+qwen3.5-plus
+jev-1.13
+big-pickle
+jev-1.13-free
+exo-free
+muse-spark-1.3-contributor-free
+muse-spark-1.2-contributor-free
+mimo-v2.6-flash-free
+space-bunny-free
+longcat-2.5-preview-free
+step-5-preview-free
+ling-3.0-flash-fin-free
+nemotron-3-ultra-free
+nemotron-3.5-lightning-free
+qwen3.8-max
+ling-3.1-flash-free

opencode_models/sources.py

@@ -0,0 +1,55 @@
+"""Membership lists for the OpenCode Console tiers (zen = curated, go = open).
+
+Slugs are bare model ids (``claude-opus-5``) as listed on the tier pages,
+shipped as text files beside this module. Matching against the catalog
+happens on the slug (last path segment of ``lab/model``).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from .data import Model
+
+_DIR = Path(__file__).resolve().parent / "sources"
+
+
+def available_sources() -> list[str]:
+    """Tier names that have a shipped membership file."""
+    return sorted(p.stem for p in _DIR.glob("*.txt"))
+
+
+def load_source(name: str) -> set[str]:
+    """Slugs of models in tier *name*; raises KeyError for unknown tiers."""
+    path = _DIR / f"{name}.txt"
+    if not path.exists():
+        raise KeyError(name)
+    return {line.strip() for line in path.read_text().splitlines() if line.strip()}
+
+
+def members(
+    models: list[Model], slugs: set[str] | None
+) -> tuple[list[Model], set[str]]:
+    """Tier membership: the models in a tier, plus which of them are free.
+
+    The tier pages list free variants under their own slug
+    (``mimo-v2.6-flash-free``, ``step-5-preview-free``) while the catalog
+    carries one model under the base slug, so ``X-free`` has to reach ``X``.
+    A member reached through a ``-free`` slug — or priced at zero — is free.
+    """
+    if slugs is None:  # `--source all`: no tier filter
+        return (list(models), {m.model_id for m in models if m.price_input == 0})
+    included: list[Model] = []
+    free: set[str] = set()
+    for m in models:
+        slug = m.model_id.split("/")[-1]
+        if slug in slugs or m.model_id in slugs:
+            matched_free = False
+        elif f"{slug}-free" in slugs:
+            matched_free = True
+        else:
+            continue
+        included.append(m)
+        if matched_free or m.price_input == 0:
+            free.add(m.model_id)
+    return included, free

opencode_models/tables.py

@@ -0,0 +1,94 @@
+"""Aligned text tables from declarative input.
+
+Every console view was hand-rolling the same loop: measure the widest
+cell per column (header included), pad, join, print — with the widths
+and the alignment re-decided at each site, so a wide cell silently
+broke the grid instead of widening it. These helpers take headers plus
+rows of plain strings and return aligned text; the views only declare
+*what* goes in each column, never how wide it is.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+
+def column_widths(
+    headers: Sequence[str],
+    rows: Sequence[Sequence[str]],
+    min_widths: Sequence[int] = (),
+) -> list[int]:
+    """The display width of each column: header, cells and floor combined."""
+    count = max([len(headers)] + [len(r) for r in rows] or [0])
+    widths = []
+    for i in range(count):
+        cells = [r[i] for r in rows if len(r) > i]
+        floor = min_widths[i] if i < len(min_widths) else 0
+        widths.append(
+            max(
+                [len(headers[i]) if i < len(headers) else 0, floor]
+                + [len(c) for c in cells]
+                or [0]
+            )
+        )
+    return widths
+
+
+def _pad(cell: str, width: int, align: str) -> str:
+    return cell.ljust(width) if align == "<" else cell.rjust(width)
+
+
+def _aligns_for(aligns: str | Sequence[str], count: int) -> list[str]:
+    if isinstance(aligns, str):
+        return [aligns] * count
+    return list(aligns) + [">"] * (count - len(aligns))
+
+
+def format_row(
+    cells: Sequence[str],
+    widths: Sequence[int],
+    aligns: str | Sequence[str] = ">",
+    gap: str = "  ",
+) -> str:
+    """One grid line: padded cells joined, trailing padding stripped.
+
+    Short rows pad out with blanks; a row wider than the grid is a caller
+    bug and raises instead of silently dropping a column.
+    """
+    if len(cells) > len(widths):
+        raise ValueError(
+            f"row has {len(cells)} cells for {len(widths)} columns: {cells!r}"
+        )
+    padded = [cells[i] if i < len(cells) else "" for i in range(len(widths))]
+    return gap.join(
+        _pad(c, w, a)
+        for c, w, a in zip(
+            padded, widths, _aligns_for(aligns, len(widths)), strict=True
+        )
+    ).rstrip()
+
+
+def render(
+    headers: Sequence[str],
+    rows: Sequence[Sequence[str]],
+    aligns: str | Sequence[str] = ">",
+    header_aligns: str | Sequence[str] | None = None,
+    min_widths: Sequence[int] = (),
+    indent: str = "",
+    gap: str = "  ",
+) -> str:
+    """Headers plus rows as aligned text, one line each, no trailing newline.
+
+    Columns measure across the headers and every row, so a wide cell
+    widens its column instead of breaking the grid; *min_widths* holds
+    narrow columns open where a fixed layout is wanted. Short rows pad
+    out with blanks. Every line is *indent*ed and right-stripped.
+    """
+    widths = column_widths(headers, rows, min_widths)
+    lines = [
+        format_row(
+            headers, widths, header_aligns if header_aligns is not None else aligns, gap
+        )
+    ]
+    lines += [format_row(row, widths, aligns, gap) for row in rows]
+    return "\n".join(indent + line for line in lines)