weightspace 0.1.0__py3-none-any.whl

weightspace/llm/__init__.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+from .base import LLM, LLMResponse, ToolCall, normalize_thinking
+from .mock import ScriptedLLM, call, reply
+
+
+def get_llm(spec: str | LLM, **kw) -> LLM:
+    """`"openai:gpt-5"`, `"anthropic:claude-sonnet-4-5"`, or `"openrouter:<model>"`."""
+    if isinstance(spec, LLM):
+        return spec
+    provider, _, model = spec.partition(":")
+    if not model:
+        provider, model = "openai", provider
+    provider = provider.lower()
+    if provider == "anthropic":
+        from .anthropic import AnthropicChat
+
+        return AnthropicChat(model, **kw)
+    if provider == "openrouter":
+        import os
+
+        from .openai import OpenAIChat
+
+        kw.setdefault("base_url", "https://openrouter.ai/api/v1")
+        kw.setdefault("api_key", os.environ.get("OPENROUTER_API_KEY"))
+        kw.setdefault("thinking_style", "openrouter")
+        return OpenAIChat(model, **kw)
+    if provider == "openai":
+        from .openai import OpenAIChat
+
+        return OpenAIChat(model, **kw)
+    raise ValueError(f"unknown provider {provider!r}")
+
+
+__all__ = ["normalize_thinking", "LLM", "LLMResponse", "ToolCall", "ScriptedLLM", "call", "reply", "get_llm"]

weightspace/llm/anthropic.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+
+import os
+
+from .base import LLM, LLMResponse, ToolCall, normalize_thinking
+
+THINKING_BUDGET = {"low": 2048, "medium": 8192, "high": 16384, "xhigh": 24576, "max": 32000}
+
+
+def to_anthropic(messages: list[dict]) -> tuple[str, list[dict]]:
+    system, out = [], []
+    for m in messages:
+        role = m["role"]
+        if role == "system":
+            system.append(m["content"])
+        elif role == "user":
+            out.append({"role": "user", "content": [{"type": "text", "text": m["content"]}]})
+        elif role == "assistant":
+            if m.get("anthropic_content"):
+                blocks = m["anthropic_content"]
+            else:
+                blocks = [{"type": "text", "text": m["content"]}] if m.get("content") else []
+                blocks += [
+                    {"type": "tool_use", "id": t["id"], "name": t["name"], "input": t["arguments"]}
+                    for t in m.get("tool_calls") or []
+                ]
+            out.append({"role": "assistant", "content": blocks})
+        elif role == "tool":
+            block = {"type": "tool_result", "tool_use_id": m["tool_call_id"], "content": m["content"]}
+            if out and out[-1]["role"] == "user" and all(b["type"] == "tool_result" for b in out[-1]["content"]):
+                out[-1]["content"].append(block)
+            else:
+                out.append({"role": "user", "content": [block]})
+    merged: list[dict] = []
+    for m in out:
+        if merged and merged[-1]["role"] == m["role"] == "user":
+            merged[-1]["content"].extend(m["content"])
+        else:
+            merged.append(m)
+    return "\n\n".join(system), merged
+
+
+class AnthropicChat(LLM):
+    """Anthropic Messages API.
+
+    thinking_style: "adaptive" (thinking.type=adaptive + output_config.effort, newer models), "budget"
+    (thinking.type=enabled + budget_tokens, older models) or "auto" (adaptive, falling back to budget if the
+    model rejects it).
+    """
+
+    def __init__(
+        self,
+        model: str,
+        *,
+        api_key: str | None = None,
+        max_tokens: int = 16000,
+        client=None,
+        thinking=None,
+        thinking_style: str = "auto",
+        cache: bool = True,
+        **params,
+    ):
+        if client is None:
+            from anthropic import Anthropic
+
+            client = Anthropic(api_key=api_key or os.environ.get("ANTHROPIC_API_KEY"))
+        self.client = client
+        self.model = model
+        self.name = f"anthropic:{model}"
+        self.max_tokens = max_tokens
+        self.params = params
+        self.thinking = normalize_thinking(thinking)
+        if thinking_style not in ("auto", "adaptive", "budget"):
+            raise ValueError("thinking_style must be 'auto', 'adaptive' or 'budget'")
+        self.thinking_style = thinking_style
+        self.cache = cache
+
+    def _thinking_kwargs(self, style: str) -> tuple[dict, int]:
+        t = normalize_thinking(self.thinking)
+        if t is None:
+            return {}, self.max_tokens
+        if t == "off":
+            return {"thinking": {"type": "disabled"}}, self.max_tokens
+        if style == "budget":
+            budget = THINKING_BUDGET[t]
+            return {"thinking": {"type": "enabled", "budget_tokens": budget}}, max(self.max_tokens, budget + 4096)
+        return {"thinking": {"type": "adaptive"}, "output_config": {"effort": t}}, self.max_tokens
+
+    def complete(self, messages, tools=None):
+        system, msgs = to_anthropic(messages)
+        if self.cache and msgs and msgs[-1]["content"]:
+            # prompt caching: everything up to the newest block is reused on the next step
+            msgs[-1]["content"][-1] = {**msgs[-1]["content"][-1], "cache_control": {"type": "ephemeral"}}
+        kw = dict(self.params)
+        if system:
+            kw["system"] = system
+        if tools:
+            kw["tools"] = [{"name": t["name"], "description": t["description"], "input_schema": t["parameters"]} for t in tools]
+        style = "adaptive" if self.thinking_style == "auto" else self.thinking_style
+        tk, max_tokens = self._thinking_kwargs(style)
+        try:
+            r = self.client.messages.create(model=self.model, max_tokens=max_tokens, messages=msgs, **kw, **tk)
+        except Exception as e:
+            if self.thinking_style != "auto" or "thinking" not in tk or "adaptive" not in str(e):
+                raise
+            self.thinking_style = "budget"
+            tk, max_tokens = self._thinking_kwargs("budget")
+            r = self.client.messages.create(model=self.model, max_tokens=max_tokens, messages=msgs, **kw, **tk)
+        if self.thinking_style == "auto":
+            self.thinking_style = style
+        text, calls, blocks = [], [], []
+        for b in r.content:
+            blocks.append(b.model_dump(exclude_none=True) if hasattr(b, "model_dump") else dict(b))
+            if b.type == "text":
+                text.append(b.text)
+            elif b.type == "tool_use":
+                calls.append(ToolCall(b.id, b.name, dict(b.input)))
+        usage = r.usage.model_dump() if getattr(r, "usage", None) is not None else {}
+        return LLMResponse(
+            text="\n".join(text) or None,
+            tool_calls=calls,
+            usage=usage,
+            raw=r,
+            extra={"anthropic_content": blocks},
+        )

weightspace/llm/base.py

@@ -0,0 +1,71 @@
+"""Provider-neutral chat interface.
+
+Messages use an OpenAI-like neutral shape:
+  {"role": "system"|"user", "content": str}
+  {"role": "assistant", "content": str|None, "tool_calls": [{"id", "name", "arguments"}]}
+  {"role": "tool", "tool_call_id": str, "name": str, "content": str}
+Tools are {"name", "description", "parameters": <JSON schema>}.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class ToolCall:
+    id: str
+    name: str
+    arguments: dict
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "name": self.name, "arguments": self.arguments}
+
+
+@dataclass
+class LLMResponse:
+    text: str | None = None
+    tool_calls: list[ToolCall] = field(default_factory=list)
+    usage: dict = field(default_factory=dict)
+    raw: Any = None
+    extra: dict = field(default_factory=dict)  # provider state to replay (e.g. thinking blocks)
+
+    def to_message(self) -> dict:
+        msg = {"role": "assistant", "content": self.text, "tool_calls": [t.to_dict() for t in self.tool_calls]}
+        msg.update(self.extra)
+        return msg
+
+
+THINKING_LEVELS = ("off", "low", "medium", "high", "xhigh", "max")
+
+
+def normalize_thinking(value) -> str | None:
+    """None = provider default; False/"off" = no reasoning; True = "medium"; or "low"/"medium"/"high"."""
+    if value is None:
+        return None
+    if value is False:
+        return "off"
+    if value is True:
+        return "medium"
+    v = str(value).lower()
+    if v in ("none", "disabled", "false", "no"):
+        return "off"
+    if v in ("on", "true", "enabled"):
+        return "medium"
+    if v not in THINKING_LEVELS:
+        raise ValueError(f"thinking must be None, a bool, or one of {THINKING_LEVELS}")
+    return v
+
+
+class LLM:
+    """Implement `complete` to plug in any provider.
+
+    `thinking` is set by `Session(thinking=...)`; backends map it to their own reasoning switch.
+    """
+
+    name = "llm"
+    thinking: str | None = None
+
+    def complete(self, messages: list[dict], tools: list[dict] | None = None) -> LLMResponse:
+        raise NotImplementedError

weightspace/llm/mock.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import itertools
+from collections.abc import Callable
+
+from .base import LLM, LLMResponse, ToolCall
+
+_ids = itertools.count()
+
+
+def call(name: str, /, **arguments) -> ToolCall:
+    return ToolCall(f"call_{next(_ids)}", name, arguments)
+
+
+def reply(text: str | None = None, *calls: ToolCall) -> LLMResponse:
+    return LLMResponse(text=text, tool_calls=list(calls))
+
+
+class ScriptedLLM(LLM):
+    """Replays a fixed script; each step is an LLMResponse or fn(messages, tools) -> LLMResponse.
+
+    Useful for tests and for replaying logged runs without paying for tokens.
+    """
+
+    name = "scripted"
+
+    def __init__(self, steps: list[LLMResponse | Callable[[list[dict], list[dict]], LLMResponse]]):
+        self.steps = list(steps)
+        self.seen: list[list[dict]] = []
+        self.thinking_seen: list[str | None] = []
+
+    def complete(self, messages, tools=None):
+        self.seen.append([dict(m) for m in messages])
+        self.thinking_seen.append(self.thinking)
+        if not self.steps:
+            return reply("(script exhausted)")
+        step = self.steps.pop(0)
+        return step(messages, tools or []) if callable(step) else step

weightspace/llm/openai.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+import json
+import os
+
+from .base import LLM, LLMResponse, ToolCall, normalize_thinking
+
+
+def to_openai_messages(messages: list[dict]) -> list[dict]:
+    out = []
+    for m in messages:
+        if m["role"] == "assistant":
+            msg = {"role": "assistant", "content": m.get("content")}
+            if m.get("tool_calls"):
+                msg["tool_calls"] = [
+                    {
+                        "id": t["id"],
+                        "type": "function",
+                        "function": {"name": t["name"], "arguments": json.dumps(t["arguments"])},
+                    }
+                    for t in m["tool_calls"]
+                ]
+            out.append(msg)
+        elif m["role"] == "tool":
+            out.append({"role": "tool", "tool_call_id": m["tool_call_id"], "content": m["content"]})
+        else:
+            out.append({"role": m["role"], "content": m["content"]})
+    return out
+
+
+def to_openai_tools(tools: list[dict]) -> list[dict]:
+    return [
+        {"type": "function", "function": {"name": t["name"], "description": t["description"], "parameters": t["parameters"]}}
+        for t in tools
+    ]
+
+
+class OpenAIChat(LLM):
+    """Any OpenAI-compatible Chat Completions endpoint (OpenAI, OpenRouter, vLLM, Ollama...).
+
+    thinking_style says how `thinking` is sent:
+      "reasoning_effort"  OpenAI reasoning models (off -> `off_effort`, e.g. "none" or "minimal")
+      "openrouter"        OpenRouter's unified `reasoning` field
+      "chat_template"     vLLM / SGLang hybrid models (Qwen3...): `chat_template_kwargs.enable_thinking`
+      None                never send anything
+    """
+
+    def __init__(
+        self,
+        model: str,
+        *,
+        api_key: str | None = None,
+        base_url: str | None = None,
+        client=None,
+        thinking=None,
+        thinking_style: str | None = "reasoning_effort",
+        off_effort: str = "none",
+        **params,
+    ):
+        if client is None:
+            from openai import OpenAI
+
+            client = OpenAI(
+                api_key=api_key or os.environ.get("OPENAI_API_KEY"),
+                base_url=base_url or os.environ.get("OPENAI_BASE_URL"),
+            )
+        self.client = client
+        self.model = model
+        self.name = f"openai:{model}"
+        self.params = params
+        self.thinking = normalize_thinking(thinking)
+        self.thinking_style = thinking_style
+        self.off_effort = off_effort
+
+    def _thinking_params(self, kw: dict) -> None:
+        t, style = normalize_thinking(self.thinking), self.thinking_style
+        if t is None or style is None:
+            return
+        extra = dict(kw.get("extra_body") or {})
+        if style == "reasoning_effort":
+            kw["reasoning_effort"] = self.off_effort if t == "off" else t
+        elif style == "openrouter":
+            extra["reasoning"] = {"enabled": False} if t == "off" else {"effort": t}
+        elif style == "chat_template":
+            ctk = dict(extra.get("chat_template_kwargs") or {})
+            ctk["enable_thinking"] = t != "off"
+            extra["chat_template_kwargs"] = ctk
+        else:
+            raise ValueError(f"unknown thinking_style {style!r}")
+        if extra:
+            kw["extra_body"] = extra
+
+    def complete(self, messages, tools=None):
+        kw = dict(self.params)
+        self._thinking_params(kw)
+        if tools:
+            kw["tools"] = to_openai_tools(tools)
+        r = self.client.chat.completions.create(model=self.model, messages=to_openai_messages(messages), **kw)
+        msg = r.choices[0].message
+        calls = []
+        for t in msg.tool_calls or []:
+            try:
+                args = json.loads(t.function.arguments or "{}")
+            except json.JSONDecodeError:
+                args = {"_raw": t.function.arguments}
+            calls.append(ToolCall(t.id, t.function.name, args))
+        usage = r.usage.model_dump() if getattr(r, "usage", None) is not None else {}
+        return LLMResponse(text=msg.content, tool_calls=calls, usage=usage, raw=r)

weightspace/probes.py

@@ -0,0 +1,60 @@
+"""Forward passes the LLM may spend, defined by the user."""
+
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from typing import Any
+
+
+@dataclass
+class Probe:
+    """A user-defined way to run the network, exposed to the LLM as a tool.
+
+    `fn` is called with the LLM's arguments after the current weights are
+    synced into the model. It decides what the LLM gets to see (scores,
+    rollouts, attention maps, generated text...).
+    """
+
+    fn: Callable[..., Any]
+    name: str = ""
+    description: str = ""
+    parameters: dict = field(default_factory=dict)
+    cost: int = 1
+
+    def __post_init__(self):
+        self.name = self.name or self.fn.__name__
+        self.description = self.description or inspect.getdoc(self.fn) or f"Run {self.name}."
+        if not self.parameters:
+            self.parameters = _schema_from_signature(self.fn)
+
+    def __call__(self, **kw):
+        return self.fn(**kw)
+
+
+def probe(fn=None, *, name: str = "", description: str = "", parameters: dict | None = None, cost: int = 1):
+    """Decorator: `@probe` or `@probe(cost=2, parameters={...})`."""
+
+    def wrap(f):
+        return Probe(f, name=name, description=description, parameters=parameters or {}, cost=cost)
+
+    return wrap(fn) if fn is not None else wrap
+
+
+_JSON_TYPES = {int: "integer", float: "number", str: "string", bool: "boolean", list: "array", dict: "object"}
+
+
+def _schema_from_signature(fn) -> dict:
+    props, required = {}, []
+    for p in inspect.signature(fn).parameters.values():
+        if p.kind in (p.VAR_POSITIONAL, p.VAR_KEYWORD):
+            continue
+        ann = p.annotation
+        origin = getattr(ann, "__origin__", ann)
+        props[p.name] = {"type": _JSON_TYPES.get(origin, "string")} if ann is not p.empty else {}
+        if p.default is p.empty:
+            required.append(p.name)
+        else:
+            props[p.name]["default"] = p.default if isinstance(p.default, (int, float, str, bool, type(None))) else str(p.default)
+    return {"type": "object", "properties": props, "required": required}

weightspace/prompts.py

@@ -0,0 +1,43 @@
+SYSTEM = """You are a weight-space programmer. You read and write the weights of a neural network directly,
+by reasoning about what each part of the network computes or should compute.
+
+Rules:
+- No gradient descent, no training loops, no fitting weights to data (no least squares on activations,
+  no optimizers, no search over random perturbations). Derive every edit from your understanding of the
+  network.
+- Do not run the network or any of its layers on inputs inside the Python sandbox, even on made-up inputs.
+  Static analysis of the weights (norms, SVD, products of weight matrices, comparisons between tensors)
+  is fine. The only way to see the network's behaviour is the forward_* tools, which spend a limited budget.
+- Prefer small, targeted edits that fix the cause and leave the rest of the network intact.
+- When you are done, call `submit` exactly once with your answer and a confidence between 0 and 1.
+"""
+
+MODES = {
+    "read": "Task type: READ. Work out the answer from the weights. You cannot change any weights.",
+    "fix": (
+        "Task type: FIX. Find the cause of the described failure in the weights, explain it, and fix only that "
+        "cause by editing weights. Use checkpoints so you can roll back an edit that does not help."
+    ),
+    "write": (
+        "Task type: WRITE. Program the network's weights so that it implements the specification. Decide what "
+        "algorithm each layer should compute, then convert it into weights."
+    ),
+    "improve": (
+        "Task type: IMPROVE. Make the network better at the stated goal by editing weights. Diagnose what limits "
+        "it first, then make targeted edits, and keep an edit only if the evidence says it helps."
+    ),
+}
+
+NO_THINKING = """
+Thinking is off for this run: do not write out step-by-step reasoning. Go straight to tool calls and weight
+edits, with at most one short sentence of explanation each.
+"""
+
+TEXT_MODE_EDIT = """Reply with your reasoning and then the edit, in ONE of these formats:
+1. A ```python block. It runs once with `W` (writable dict of numpy arrays, edit in place or assign),
+   `R` (read-only originals) and `np` in scope.
+2. One or more ```weights blocks containing `### <tensor name> [<shape>]` headers each followed by all of
+   that tensor's numbers, in the same layout as the dump you were given.
+End with a line `ANSWER: <short summary>` and a line `CONFIDENCE: <0..1>`."""
+
+TEXT_MODE_READ = "Reply with your reasoning, then a line `ANSWER: <answer>` and a line `CONFIDENCE: <0..1>`."

weightspace/render.py

@@ -0,0 +1,151 @@
+"""Turning tensors into text an LLM can read, and back."""
+
+from __future__ import annotations
+
+import re
+
+import numpy as np
+
+
+def fmt_num(x: float, precision: int = 3) -> str:
+    s = f"{x:.{precision}g}"
+    return "0" if s in ("0", "-0") else s
+
+
+def fmt_array(arr: np.ndarray, precision: int = 3) -> str:
+    """One line per row (last axis); leading axes are labelled."""
+    arr = np.asarray(arr)
+    if arr.ndim == 0:
+        return fmt_num(float(arr), precision)
+    if arr.ndim == 1:
+        return " ".join(fmt_num(float(v), precision) for v in arr)
+    flat = arr.reshape(-1, arr.shape[-1])
+    lead = list(np.ndindex(*arr.shape[:-1]))
+    rows = []
+    for idx, row in zip(lead, flat, strict=True):
+        label = ",".join(str(i) for i in idx)
+        rows.append(f"[{label}] " + " ".join(fmt_num(float(v), precision) for v in row))
+    return "\n".join(rows)
+
+
+_SLICE_PART = re.compile(r"^\s*(-?\d+)?\s*(?::\s*(-?\d+)?\s*(?::\s*(-?\d+)?\s*)?)?$")
+
+
+def parse_index(index: str | None):
+    """Parse numpy-style index text like "0:8, :, 3" without eval."""
+    if index is None or not str(index).strip():
+        return ()
+    text = str(index).strip()
+    if text.startswith("[") and text.endswith("]"):
+        text = text[1:-1]
+    out = []
+    for part in text.split(","):
+        part = part.strip()
+        if part in ("", ":", "..."):
+            out.append(Ellipsis if part == "..." else slice(None))
+            continue
+        m = _SLICE_PART.match(part)
+        if not m:
+            raise ValueError(f"bad index component {part!r}")
+        if ":" not in part:
+            out.append(int(m.group(1)))
+        else:
+            a, b, c = (int(g) if g is not None else None for g in m.groups())
+            out.append(slice(a, b, c))
+    return tuple(out)
+
+
+def stats(arr: np.ndarray) -> dict:
+    a = np.asarray(arr, dtype=np.float64).reshape(-1)
+    if a.size == 0:
+        return {"numel": 0}
+    q = np.quantile(a, [0.01, 0.25, 0.5, 0.75, 0.99])
+    return {
+        "numel": int(a.size),
+        "mean": float(a.mean()),
+        "std": float(a.std()),
+        "min": float(a.min()),
+        "max": float(a.max()),
+        "abs_mean": float(np.abs(a).mean()),
+        "frac_zero": float(np.mean(a == 0)),
+        "q01_q25_q50_q75_q99": [float(v) for v in q],
+    }
+
+
+def describe(name: str, arr: np.ndarray, dtype: str = "", top_k: int = 8) -> str:
+    """Structural summary: stats, row/col norms, spectrum for matrices."""
+    arr = np.asarray(arr)
+    s = stats(arr)
+    lines = [f"{name}: shape={tuple(arr.shape)} dtype={dtype or arr.dtype} numel={s['numel']:,}"]
+    if s["numel"] == 0:
+        return lines[0]
+    lines.append(
+        "mean={} std={} min={} max={} |x|mean={} zeros={:.3g}%".format(
+            *(fmt_num(s[k], 4) for k in ("mean", "std", "min", "max", "abs_mean")), 100 * s["frac_zero"]
+        )
+    )
+    lines.append("quantiles 1/25/50/75/99%: " + " ".join(fmt_num(v, 4) for v in s["q01_q25_q50_q75_q99"]))
+    if arr.ndim >= 2:
+        m = np.asarray(arr, dtype=np.float64).reshape(arr.shape[0], -1)
+        for axis, label in ((1, "row"), (0, "col")):
+            norms = np.linalg.norm(m, axis=axis)
+            order = np.argsort(norms)[::-1]
+            top = ", ".join(f"{i}:{fmt_num(norms[i], 3)}" for i in order[:top_k])
+            low = ", ".join(f"{i}:{fmt_num(norms[i], 3)}" for i in order[::-1][:top_k])
+            lines.append(f"{label} L2 norms ({norms.size}): largest {top} | smallest {low}")
+        if min(m.shape) <= 4096 and m.size <= 16_000_000:
+            sv = np.linalg.svd(m, compute_uv=False)
+            energy = np.cumsum(sv**2) / max(np.sum(sv**2), 1e-30)
+            eff = int(np.searchsorted(energy, 0.9) + 1)
+            lines.append(
+                f"singular values (top {min(top_k, sv.size)}): "
+                + " ".join(fmt_num(v, 3) for v in sv[:top_k])
+                + f" | rank for 90% energy: {eff}/{sv.size}"
+            )
+    return "\n".join(lines)
+
+
+def render_space(ws, precision: int = 3) -> str:
+    """Full text dump in the same format `parse_weights` reads back."""
+    parts = []
+    for n in ws.names():
+        arr = ws[n]
+        parts.append(f"### {n} {list(arr.shape)}\n{fmt_array(arr, precision)}")
+    return "\n\n".join(parts)
+
+
+_HEADER = re.compile(r"^###\s+(\S+)(?:\s+\[([\d,\s]*)\])?\s*$")
+_NUM = re.compile(r"[-+]?(?:\d+\.?\d*|\.\d+)(?:[eE][-+]?\d+)?")
+
+
+def parse_weights(text: str) -> dict[str, np.ndarray]:
+    """Parse `### name [shape]` blocks of numbers (row labels like [0,1] are ignored)."""
+    out: dict[str, np.ndarray] = {}
+    name, shape, nums = None, None, []
+
+    def done():
+        if name is None:
+            return
+        arr = np.array(nums, dtype=np.float32)
+        if shape is not None:
+            arr = arr.reshape(shape)
+        out[name] = arr
+
+    for line in text.splitlines():
+        m = _HEADER.match(line.strip())
+        if m:
+            done()
+            name = m.group(1)
+            shape = tuple(int(x) for x in m.group(2).split(",") if x.strip()) if m.group(2) is not None else None
+            nums = []
+            continue
+        if name is None:
+            continue
+        body = re.sub(r"^\s*\[[\d,\s]*\]", "", line)
+        nums.extend(float(x) for x in _NUM.findall(body))
+    done()
+    return out
+
+
+def extract_blocks(text: str, lang: str) -> list[str]:
+    return [m.group(1) for m in re.finditer(rf"```{lang}[^\n]*\n(.*?)```", text, re.S)]