remove dev tooling + staging notes from package (tests, make_charts, UPLOAD, ARCHITECTURE-VIEWER, pycache, benchmark_table.md)

ARCHITECTURE-VIEWER.md

@@ -1,35 +0,0 @@
-# Hugging Face native architecture viewer — investigation verdict
-
-**Question:** Does the Hugging Face model page render a native architecture viewer
-for a custom-model (`model_type: minspark`, `trust_remote_code`) private repo?
-
-**Verdict: No.** The Hub's model-page architecture display is driven by a curated
-mapping of *recognized* transformers architectures (Llama, Mistral, GPT-2, BERT,
-Qwen, …) plus `safetensors` parameter metadata. It does not:
-
-- derive a diagram from a custom `config.json` + `auto_map` remote-code model, or
-- compute a parameter/architecture readout for an unknown `model_type`.
-
-Sources consulted (2026-08-06):
-
-- `huggingface.js` `packages/tasks/src/model-data.ts` — `ModelData.config` is a
-  passthrough of `architectures`/`model_type`/`auto_map`; no formula or per-arch
-  computation, no unknown-model fallback.
-- `packages/tasks/src/model-libraries-snippets.ts` — snippet generation branches
-  on `pipeline_tag`/tags, not on a custom `model_type`.
-- Hub model-card docs (`docs/hub/model-cards`) — the card renders metadata
-  (license, pipeline_tag, library_name, eval results) and markdown images; there
-  is no universal architecture diagram for arbitrary custom code.
-- transformers `PreTrainedModel.from_pretrained` internals — `trust_remote_code`
-  loads the custom module for *inference*; nothing emits a Hub-side diagram.
-
-For a **private** repo the effect is even more pronounced: the model page shows
-limited metadata and no architecture visualization for any unrecognized
-architecture.
-
-**Shipping decision:** the model card embeds a hand-authored `architecture.svg`
-(horizontal dataflow diagram) as the robust fallback. If Hugging Face later
-adds native viewer support for custom remote-code models, the SVG remains a
-correct, dependency-free description of the architecture.
-
-(Staging-only note — excluded from the Hub upload.)

UPLOAD.md

@@ -1,83 +0,0 @@
-# min-spark Upload Plan (staging-only — no upload performed)
-
-**Target repo:** `MinimaLabs/min-spark` — **PRIVATE**, `type=model`.
-
-> This document is the upload-ready summary. No `hf repos create`/`hf upload`
-> was run during staging. The user reviews the staged package and authorizes
-> the upload.
-
-## Tooling verified
-
-- `hf` CLI version: **1.17.0** (`hf version`)
-- `huggingface_hub` in the packaging venv (`~/.venvs/pico-hf`): **1.26.0**
-
-## Staging → Hub file mapping
-
-| Staging file | Hub path | Included? |
-|--------------|----------|-----------|
-| `model.safetensors` | `model.safetensors` | ✅ weights |
-| `tokenizer.json` | `tokenizer.json` | ✅ tokenizer |
-| `config.json` | `config.json` | ✅ |
-| `configuration_minspark.py` | `configuration_minspark.py` | ✅ |
-| `modeling_minspark.py` | `modeling_minspark.py` | ✅ |
-| `meiosis.py` | `meiosis.py` | ✅ vendored model |
-| `tokenizer_config.json` | `tokenizer_config.json` | ✅ |
-| `special_tokens_map.json` | `special_tokens_map.json` | ✅ |
-| `generation_config.json` | `generation_config.json` | ✅ |
-| `README.md` | `README.md` | ✅ model card |
-| `LICENSE` | `LICENSE` | ✅ Apache-2.0 |
-| `requirements.txt` | `requirements.txt` | ✅ |
-| `requirements-eval.txt` | `requirements-eval.txt` | ✅ |
-| `run_lmeval.py` | `run_lmeval.py` | ✅ reproduction |
-| `record_deltas.py` | `record_deltas.py` | ✅ |
-| `deltas.json` | `deltas.json` | ✅ measured deltas |
-| `charts/accuracy.svg` | `charts/accuracy.svg` | ✅ |
-| `charts/byteppl.svg` | `charts/byteppl.svg` | ✅ |
-| `architecture.svg` | `architecture.svg` | ✅ |
-| `make_charts.py` | — | ❌ dev tool |
-| `UPLOAD.md` | — | ❌ staging note |
-| `ARCHITECTURE-VIEWER.md` | — | ❌ staging note |
-| `tests/` | — | ❌ test suite |
-| `__pycache__/`, `*.pyc` | — | ❌ |
-
-## Exact upload command
-
-```bash
-cd models/2026-07-meiosis/hf/min-spark
-
-# 1. Create the PRIVATE model repo (user runs this)
-hf repos create MinimaLabs/min-spark --type model --private
-
-# 2. Upload the full staging dir, excluding dev tooling + staging notes
-#    (model.safetensors + tokenizer.json ARE included — not in the exclude set)
-hf upload MinimaLabs/min-spark . \
-  --include "*" \
-  --exclude "tests/ make_charts.py UPLOAD.md ARCHITECTURE-VIEWER.md __pycache__/** *.pyc .*_cache/**"
-```
-
-The `hf upload` uses `--include "*"` to pull everything in the staging dir, and
-the `--exclude` set removes the dev tooling and the two staging-only notes. The
-weights and tokenizer (gitignored in PICO git) are uploaded because they are
-not in the exclude set.
-
-> Note: `hf upload` excludes are space-separated globs. Verify the resulting
-> file list with `hf upload MinimaLabs/min-spark . --dry-run ...` (if supported)
-> before the real upload.
-
-## Post-upload checklist (user verifies on the private page)
-
-- [ ] README renders — quickstart, effort table, benchmark table, charts, SVG.
-- [ ] Benchmark table values match `charts/benchmark_table.md` exactly.
-- [ ] `Use in Transformers` button shows the model card snippet.
-- [ ] "Use in Transformers" snippet works: `AutoModelForCausalLM.from_pretrained(
-      "MinimaLabs/min-spark", trust_remote_code=True)`.
-- [ ] License badge shows Apache-2.0.
-- [ ] Architecture viewer verdict recorded (no native viewer for custom
-      `model_type`; `architecture.svg` is the fallback).
-- [ ] `pipeline_tag: text-generation` shows the text-generation widget.
-- [ ] The repo is private (verified under the org).
-
-## No upload was performed during staging
-
-The staging suite is fully green; the two integration paths are validated; the
-stock-HFLM deltas are measured. Upload awaits explicit user authorization.

charts/benchmark_table.md

@@ -1,5 +0,0 @@
-| Effort | BLiMP | ARC-Easy | ARC-Challenge | HellaSwag | PIQA | WikiText-2 byte-ppl |
-|--------|-------|----------|---------------|-----------|------|---------------------|
-| min-spark-low | 67.11% | 35.10% | 23.21% | 27.91% | 54.13% | 2.8783 |
-| min-spark-medium | 69.19% | 37.08% | 22.78% | 27.92% | 54.30% | 2.7747 |
-| min-spark-high | 69.18% | 37.08% | 22.87% | 27.91% | 54.35% | 2.7747 |

make_charts.py

@@ -1,104 +0,0 @@
-"""Generate model-card charts from results_all_k.json (staging-only tool).
-
-Reads the AGGREGATE `blimp` key (top-level "blimp" -> "acc,none"), never the
-mean of the 67 blimp_* subtasks. Accuracy tasks use acc_norm,none
-(arc_easy/arc_challenge/hellaswag/piqa); byte-perplexity uses
-byte_perplexity,none. Effort colors are fixed across every chart.
-Also writes charts/benchmark_table.md (the source-of-truth table).
-"""
-from __future__ import annotations
-
-import json
-from pathlib import Path
-
-import matplotlib
-matplotlib.use("Agg")
-# Real <text> elements (not glyph paths) so labels are inspectable in the SVG
-# and the model-card renders them as selectable text.
-matplotlib.rcParams["svg.fonttype"] = "none"
-import matplotlib.pyplot as plt
-
-HERE = Path(__file__).resolve().parent
-RESULTS = (HERE / ".." / ".." / "results" / "decay-p09" / "results_all_k.json").resolve()
-OUT = HERE / "charts"
-
-EFFORTS = ["2", "3", "4"]
-EFFORT_LABELS = ["min-spark-low", "min-spark-medium", "min-spark-high"]
-EFFORT_COLORS = {"2": "#4C72B0", "3": "#DD8452", "4": "#55A868"}
-ACC_TASKS = [
-    ("BLiMP", "blimp", "acc,none"),
-    ("ARC-Easy", "arc_easy", "acc_norm,none"),
-    ("ARC-Challenge", "arc_challenge", "acc_norm,none"),
-    ("HellaSwag", "hellaswag", "acc_norm,none"),
-    ("PIQA", "piqa", "acc_norm,none"),
-]
-KEY = "acc_norm,none"
-
-
-def load() -> dict:
-    return json.loads(RESULTS.read_text())
-
-
-def make_accuracy(data: dict) -> None:
-    fig, ax = plt.subplots(figsize=(9, 4.6))
-    x = range(len(ACC_TASKS))
-    width = 0.26
-    for i, k in enumerate(EFFORTS):
-        vals = [data[k][jkey][key] * 100 for _, jkey, key in ACC_TASKS]
-        ax.bar([xi + (i - 1) * width for xi in x], vals, width,
-               label=EFFORT_LABELS[i], color=EFFORT_COLORS[k])
-    ax.set_ylabel("Accuracy (%)")
-    ax.set_ylim(0, 100)
-    ax.set_xticks(list(x))
-    ax.set_xticklabels([t for t, _, _ in ACC_TASKS])
-    ax.legend(frameon=False)
-    ax.set_title("min-spark accuracy by effort")
-    fig.tight_layout()
-    fig.savefig(OUT / "accuracy.svg")
-    plt.close(fig)
-
-
-def make_byteppl(data: dict) -> None:
-    fig, ax = plt.subplots(figsize=(6, 4))
-    vals = [data[k]["wikitext"]["byte_perplexity,none"] for k in EFFORTS]
-    ax.bar(EFFORT_LABELS, vals, color=[EFFORT_COLORS[k] for k in EFFORTS])
-    ax.set_ylabel("WikiText-2 byte perplexity (lower is better)")
-    for i, v in enumerate(vals):
-        ax.text(i, v + 0.01, f"{v:.4f}", ha="center")
-    ax.set_title("min-spark byte perplexity by effort")
-    fig.tight_layout()
-    fig.savefig(OUT / "byteppl.svg")
-    plt.close(fig)
-
-
-def make_table(data: dict) -> str:
-    lines = [
-        "| Effort | BLiMP | ARC-Easy | ARC-Challenge | HellaSwag | PIQA | WikiText-2 byte-ppl |",
-        "|--------|-------|----------|---------------|-----------|------|---------------------|",
-    ]
-    for k in EFFORTS:
-        e = data[k]
-        row = (
-            f"| {EFFORT_LABELS[int(k)-2]} "
-            f"| {e['blimp']['acc,none']*100:.2f}% "
-            f"| {e['arc_easy']['acc_norm,none']*100:.2f}% "
-            f"| {e['arc_challenge']['acc_norm,none']*100:.2f}% "
-            f"| {e['hellaswag']['acc_norm,none']*100:.2f}% "
-            f"| {e['piqa']['acc_norm,none']*100:.2f}% "
-            f"| {e['wikitext']['byte_perplexity,none']:.4f} |"
-        )
-        lines.append(row)
-    return "\n".join(lines) + "\n"
-
-
-def main() -> None:
-    OUT.mkdir(parents=True, exist_ok=True)
-    data = load()
-    make_accuracy(data)
-    make_byteppl(data)
-    (OUT / "benchmark_table.md").write_text(make_table(data))
-    print(f"wrote {OUT/'accuracy.svg'}, {OUT/'byteppl.svg'}, {OUT/'benchmark_table.md'}")
-
-
-if __name__ == "__main__":
-    main()

tests/conftest.py

@@ -1,6 +0,0 @@
-import sys
-from pathlib import Path
-
-STAGING = Path(__file__).resolve().parents[1]
-if str(STAGING) not in sys.path:
-    sys.path.insert(0, str(STAGING))

tests/test_architecture.py

@@ -1,19 +0,0 @@
-import xml.etree.ElementTree as ET
-from pathlib import Path
-
-STAGING = Path(__file__).resolve().parents[1]
-
-
-def test_architecture_svg_is_valid_and_complete():
-    p = STAGING / "architecture.svg"
-    tree = ET.parse(p)
-    root = tree.getroot()
-    text = ET.tostring(root, encoding="unicode")
-    for label in ["embed", "prelude", "body", "loop", "coda", "unembed"]:
-        assert label.lower() in text.lower(), label
-
-
-def test_viewer_note_records_verdict():
-    note = (STAGING / "ARCHITECTURE-VIEWER.md").read_text()
-    assert "native" in note.lower() or "viewer" in note.lower()
-    assert "private" in note.lower()

tests/test_charts.py

@@ -1,35 +0,0 @@
-import json
-from pathlib import Path
-
-STAGING = Path(__file__).resolve().parents[1]
-
-
-def test_charts_generated():
-    import subprocess, sys
-    out = subprocess.run([sys.executable, str(STAGING / "make_charts.py")],
-                         capture_output=True, text=True, cwd=str(STAGING), timeout=120)
-    assert out.returncode == 0, out.stderr[-1000:]
-    assert (STAGING / "charts" / "accuracy.svg").exists()
-    assert (STAGING / "charts" / "byteppl.svg").exists()
-    assert (STAGING / "charts" / "benchmark_table.md").exists()
-
-
-def test_table_uses_aggregate_blimp_and_exact_keys():
-    table = (STAGING / "charts" / "benchmark_table.md").read_text()
-    # aggregate BLiMP values (NOT an average of the 67 subtasks)
-    assert "67.11" in table and "69.19" in table
-    # byte-perplexity values
-    assert "2.8783" in table and "2.7747" in table
-    # effort names, not K labels, in headings
-    assert "min-spark-low" in table and "min-spark-medium" in table and "min-spark-high" in table
-
-
-def test_accuracy_chart_has_single_0_100_axis():
-    import xml.etree.ElementTree as ET
-    svg = (STAGING / "charts" / "accuracy.svg").read_text()
-    root = ET.fromstring(svg)
-    labels = [t.text for t in root.iter() if t.tag.endswith("text") and t.text]
-    assert "Accuracy (%)" in labels
-    # 0-100 axis: y-axis tick labels reach 100, not a 0-1 fraction axis
-    assert any(lbl.strip() == "100" for lbl in labels)
-    assert not any(lbl.strip().startswith("0.") for lbl in labels)  # no 0.7x fractions

tests/test_config.py

@@ -1,40 +0,0 @@
-import json
-from pathlib import Path
-
-STAGING = Path(__file__).resolve().parents[1]
-
-
-def test_config_json_round_trips():
-    from configuration_minspark import MinSparkConfig
-    raw = json.loads((STAGING / "config.json").read_text())
-    cfg = MinSparkConfig.from_dict(raw)
-    assert cfg.vocab_size == 4096 and cfg.dim == 288 and cfg.max_loops == 4
-    assert cfg.effort == "medium" and cfg.use_cache is False
-    assert cfg.max_position_embeddings == 512
-    back = json.loads(cfg.to_json_string())
-    assert back["model_type"] == "minspark"
-    assert back["doc_mask_eos"] == 2 and abs(back["ddl_k_eps"] - 0.01) < 1e-9
-
-
-def test_to_meiosis_preserves_training_fields():
-    from configuration_minspark import MinSparkConfig
-    from meiosis import MeiosisConfig
-    cfg = MinSparkConfig.from_dict(json.loads((STAGING / "config.json").read_text()))
-    m = cfg.to_meiosis()
-    assert isinstance(m, MeiosisConfig)
-    assert m.max_seq_len == 512 and m.doc_mask_eos == 2
-    assert abs(m.ddl_k_eps - 1e-2) < 1e-9
-    assert m.n_kv_heads == 2
-
-
-def test_max_position_embeddings_derived_from_max_seq_len():
-    from configuration_minspark import MinSparkConfig
-    cfg = MinSparkConfig()
-    assert cfg.max_position_embeddings == cfg.max_seq_len == 512
-    cfg2 = MinSparkConfig(max_seq_len=1024)
-    assert cfg2.max_position_embeddings == 1024
-
-
-def test_effort_default_and_validation_source():
-    from configuration_minspark import MinSparkConfig
-    assert MinSparkConfig().effort == "medium"

tests/test_generate.py

@@ -1,101 +0,0 @@
-import torch
-import pytest
-
-STAGING = None
-
-
-@pytest.fixture(scope="module", autouse=True)
-def setup():
-    global STAGING
-    from pathlib import Path
-    STAGING = Path(__file__).resolve().parents[1]
-    return
-
-
-@pytest.fixture(scope="module")
-def model():
-    from modeling_minspark import MinSparkForCausalLM
-    import json
-    from configuration_minspark import MinSparkConfig
-    from safetensors.torch import load_file
-    m = MinSparkForCausalLM(MinSparkConfig.from_dict(json.loads((STAGING / "config.json").read_text())))
-    m.model.load_state_dict(load_file(str(STAGING / "model.safetensors")), strict=False)
-    m.eval()
-    return m
-
-
-def test_generate_shape_and_stop(model):
-    ids = torch.tensor([[2, 3, 4, 5]])
-    out = model.generate(ids, max_new_tokens=8, do_sample=False)
-    assert out.ndim == 2 and out.shape[0] == 1
-    # stops at eos or hits max_new; never exceeds input+8
-    assert out.shape[1] <= ids.shape[1] + 8
-
-
-def test_generate_effort_passthrough(model):
-    # Deterministic: effort="low" must reproduce the loops=2 run EXACTLY (and
-    # high == loops=4). Equality, not inequality — greedy decoding is exact, and
-    # an inequality check could flake when two loop counts coincide on a few
-    # tokens or, worse, pass while effort is silently ignored.
-    ids = torch.tensor([[2, 3, 4, 5]])
-    with torch.no_grad():
-        a = model.generate(ids, effort="low", max_new_tokens=4, do_sample=False)
-        b = model.generate(ids, loops=2, max_new_tokens=4, do_sample=False)
-        c = model.generate(ids, effort="high", max_new_tokens=4, do_sample=False)
-        d = model.generate(ids, loops=4, max_new_tokens=4, do_sample=False)
-    assert torch.equal(a, b)
-    assert torch.equal(c, d)
-
-
-def test_generate_batched_raises(model):
-    ids = torch.tensor([[2, 3, 4, 5], [2, 6, 7, 8]])
-    with pytest.raises(ValueError, match="batched generation"):
-        model.generate(ids, max_new_tokens=2)
-
-
-def test_generate_invalid_effort_raises(model):
-    ids = torch.tensor([[2, 3, 4, 5]])
-    with pytest.raises(ValueError):
-        model.generate(ids, effort="turbo", max_new_tokens=2)
-
-
-def test_prepare_prepends_eos_then_truncates_to_last_512(model):
-    # Short prompt: the EOS prefix survives.
-    short = torch.tensor([[7, 8, 9]])
-    prep = model.prepare_inputs_for_generation(short)
-    assert prep["input_ids"].tolist() == [[2, 7, 8, 9]]
-    # Long prompt: [EOS] + 600 tokens -> last 512 of the concatenation, so the
-    # EOS drops off the front. Exact infer.py/loader.py parity (spec: "including
-    # the >512 edge where EOS drops").
-    long = torch.randint(0, 4096, (1, 600))
-    prep = model.prepare_inputs_for_generation(long)
-    ids = prep["input_ids"]
-    assert ids.shape[1] == 512
-    eos = torch.full((1, 1), 2, dtype=long.dtype)
-    assert torch.equal(ids, torch.cat([eos, long], dim=1)[:, -512:])
-
-
-def test_prepare_keeps_attention_mask_in_sync(model):
-    # generate may hand prepare a mask (tokenizer output in the quickstart, or
-    # an auto-created all-ones mask); after the EOS prepend it must still match
-    # input_ids in length, or forward's shape validation raises.
-    ids = torch.tensor([[2, 3, 4, 5]])
-    prep = model.prepare_inputs_for_generation(ids, attention_mask=torch.ones_like(ids))
-    assert prep["attention_mask"].shape == prep["input_ids"].shape
-    assert prep["attention_mask"].tolist() == [[1, 1, 1, 1, 1]]
-
-
-def test_generate_does_not_leak_machinery(model):
-    # If prepare echoed cache_position/position_ids/use_cache, forward would
-    # raise TypeError (it has no **kwargs). A clean generate is the proof.
-    # Bounded, not exact, length: eos_token_id=2 may stop greedy decoding early.
-    ids = torch.tensor([[2, 3, 4, 5]])
-    out = model.generate(ids, max_new_tokens=3, do_sample=False)
-    assert ids.shape[1] < out.shape[1] <= ids.shape[1] + 3
-
-
-def test_generation_config_matches_contract():
-    import json
-    gc = json.loads((STAGING / "generation_config.json").read_text())
-    assert gc["eos_token_id"] == 2 and gc["pad_token_id"] == 0 and gc["bos_token_id"] == 1
-    assert gc["use_cache"] is False

tests/test_lmeval.py

@@ -1,59 +0,0 @@
-import json
-import subprocess
-import sys
-from pathlib import Path
-
-import pytest
-
-STAGING = Path(__file__).resolve().parents[1]
-PY = Path(sys.executable)
-
-PUBLISHED = {
-    "arc_easy": {"key": "acc_norm,none", "value": 0.3707912457912458},
-    "wikitext": {"key": "byte_perplexity,none", "value": 2.7746719015990515},
-}
-TOL = {"acc_norm,none": 0.002, "byte_perplexity,none": 0.01}
-
-
-def test_run_lmeval_reproduces_arc_easy_k3():
-    # --effort medium reproduces the K=3 published value (K=3/K=4 happen to be
-    # bit-identical for arc_easy, so --effort high would pass by coincidence).
-    out = subprocess.run(
-        [str(PY), str(STAGING / "run_lmeval.py"), "--effort", "medium", "--tasks", "arc_easy", "--json"],
-        capture_output=True, text=True, cwd=str(STAGING), timeout=2400,
-    )
-    assert out.returncode == 0, out.stderr[-2000:]
-    # --json prints results["results"] (task -> metrics), not the full envelope
-    res = json.loads(out.stdout)["arc_easy"]
-    assert abs(res["acc_norm,none"] - PUBLISHED["arc_easy"]["value"]) <= TOL["acc_norm,none"]
-
-
-def test_run_lmeval_reproduces_wikitext_byteppl_k3():
-    out = subprocess.run(
-        [str(PY), str(STAGING / "run_lmeval.py"), "--effort", "medium", "--tasks", "wikitext", "--json"],
-        capture_output=True, text=True, cwd=str(STAGING), timeout=2400,
-    )
-    assert out.returncode == 0, out.stderr[-2000:]
-    res = json.loads(out.stdout)["wikitext"]
-    assert abs(res["byte_perplexity,none"] - PUBLISHED["wikitext"]["value"]) <= TOL["byte_perplexity,none"]
-
-
-def test_minspark_lm_instantiates():
-    # Catches the LM-vs-TemplateLM abstract-property mistake at construction
-    # time, before any scoring runs.
-    from run_lmeval import MinSparkLM
-    lm = MinSparkLM("medium")
-    assert lm.eot_token_id == 2 and lm.max_length == 512
-
-
-def test_stock_hflm_smoke_and_deltas():
-    # Stock --model hf must run a long-context task without crashing (R3), and
-    # record per-task deltas vs the SAME-subset run_lmeval value into deltas.json.
-    out = subprocess.run(
-        [str(PY), str(STAGING / "record_deltas.py"), "--tasks", "arc_easy,wikitext", "--limit", "200"],
-        capture_output=True, text=True, cwd=str(STAGING), timeout=2400,
-    )
-    assert out.returncode == 0, out.stderr[-2000:]
-    deltas = json.loads((STAGING / "deltas.json").read_text())
-    assert "arc_easy" in deltas and "wikitext" in deltas
-    assert "delta" in deltas["arc_easy"] and "delta" in deltas["wikitext"]

tests/test_modeling.py

@@ -1,115 +0,0 @@
-import torch
-import pytest
-
-STAGING = None  # set in fixture
-
-
-@pytest.fixture(scope="module", autouse=True)
-def setup():
-    global STAGING
-    from pathlib import Path
-    STAGING = Path(__file__).resolve().parents[1]
-    return
-
-
-def load_raw():
-    from safetensors.torch import load_file
-    from meiosis import Meiosis, MeiosisConfig
-    model = Meiosis(MeiosisConfig())
-    model.load_state_dict(load_file(str(STAGING / "model.safetensors")), strict=False)
-    model.eval()
-    return model
-
-
-def load_wrapper():
-    from modeling_minspark import MinSparkForCausalLM
-    from configuration_minspark import MinSparkConfig
-    import json
-    model = MinSparkForCausalLM(MinSparkConfig.from_dict(json.loads((STAGING / "config.json").read_text())))
-    from safetensors.torch import load_file
-    model.model.load_state_dict(load_file(str(STAGING / "model.safetensors")), strict=False)
-    model.eval()
-    return model
-
-
-@pytest.fixture(scope="module")
-def tokens():
-    from tokenizers import Tokenizer
-    tok = Tokenizer.from_file(str(STAGING / "tokenizer.json"))
-    ids = [2] + tok.encode("The quick brown fox jumps over the lazy dog.").ids
-    return torch.tensor([ids])
-
-
-def test_logits_parity_all_efforts(tokens):
-    raw, wrap = load_raw(), load_wrapper()
-    for loops in (2, 3, 4):
-        with torch.no_grad():
-            a = raw(tokens, loops=loops)
-            b = wrap(tokens, loops=loops).logits
-        assert torch.allclose(a, b, atol=1e-6), loops
-
-
-def test_effort_maps_to_loops(tokens):
-    wrap = load_wrapper()
-    with torch.no_grad():
-        low = wrap(tokens, effort="low").logits
-        med = wrap(tokens, effort="medium").logits
-    assert not torch.allclose(low, med)
-
-
-def test_invalid_effort_and_loops_raise(tokens):
-    wrap = load_wrapper()
-    with pytest.raises(ValueError):
-        wrap(tokens, effort="turbo")
-    with pytest.raises(ValueError):
-        wrap(tokens, loops=0)
-    with pytest.raises(ValueError):
-        wrap(tokens, loops=5)  # > max_loops
-
-
-def test_use_cache_raises(tokens):
-    wrap = load_wrapper()
-    with pytest.raises(NotImplementedError, match="KV cache"):
-        wrap(tokens, use_cache=True)
-    with pytest.raises(NotImplementedError, match="KV cache"):
-        wrap(tokens, past_key_values=("x",))
-
-
-def test_labels_loss_matches_shifted_ce(tokens):
-    wrap = load_wrapper()
-    labels = torch.randint(0, 4096, tokens.shape)
-    out = wrap(tokens, labels=labels)
-    import torch.nn.functional as F
-    logits = wrap(tokens).logits
-    shift_logits = logits[:, :-1, :].contiguous()
-    shift_labels = labels[:, 1:].contiguous()
-    expected = F.cross_entropy(shift_logits.view(-1, 4096), shift_labels.view(-1), ignore_index=-100)
-    assert torch.allclose(out.loss, expected, atol=1e-6)
-
-
-def test_padding_guards(tokens):
-    wrap = load_wrapper()
-    b = torch.tensor([[2, 5, 6, 0], [2, 5, 6, 7]])  # left pad
-    with pytest.raises(ValueError, match="left-padded"):
-        wrap(b, attention_mask=torch.tensor([[0, 1, 1, 1], [1, 1, 1, 1]]))
-    interior = torch.tensor([[2, 5, 6, 7]])
-    with pytest.raises(ValueError, match="suffix"):
-        wrap(interior, attention_mask=torch.tensor([[1, 1, 0, 1]]))
-
-
-def test_right_padded_scoring_matches_unbatched(tokens):
-    # Real right-padding: a PAD TOKEN (id 0) sits in position 3. The guard must
-    # pass it, and logits at the REAL positions must equal the unpadded forward.
-    # Tolerance is atol=1e-4, not 1e-6: cross-length comparison (4 vs 3 columns)
-    # changes SDPA's softmax reduction order, producing ~2.6e-5 fp noise even with
-    # the doc-mask OFF (measured). A pad-token LEAK would be O(1) in the logits —
-    # same-length pad-vs-nonpad token comparison is bit-exact (0.0), proving the
-    # mask/causal logic is correct and the residual diff is shape noise.
-    wrap = load_wrapper()
-    padded = torch.tensor([[2, 5, 6, 0]])             # token 0 = <pad> in the tail
-    mask = torch.tensor([[1, 1, 1, 0]])
-    unpadded = torch.tensor([[2, 5, 6]])
-    with torch.no_grad():
-        a = wrap(padded, attention_mask=mask).logits  # real positions 0..2
-        b = wrap(unpadded).logits                     # unpadded reference, 3 tokens
-    assert torch.allclose(a[:, :3], b[:, :3], atol=1e-4)

tests/test_pipeline.py

@@ -1,34 +0,0 @@
-import pytest
-
-STAGING = None
-
-
-@pytest.fixture(scope="module", autouse=True)
-def setup():
-    global STAGING
-    from pathlib import Path
-    STAGING = Path(__file__).resolve().parents[1]
-    return
-
-
-@pytest.fixture(scope="module")
-def pipe():
-    from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-    model = AutoModelForCausalLM.from_pretrained(str(STAGING), trust_remote_code=True)
-    tok = AutoTokenizer.from_pretrained(str(STAGING), trust_remote_code=True)
-    return pipeline("text-generation", model=model, tokenizer=tok)
-
-
-def test_pipeline_generates_text(pipe):
-    out = pipe("Hello,", max_new_tokens=6, do_sample=False)
-    assert isinstance(out, list) and len(out) == 1
-    assert out[0]["generated_text"].strip()
-
-
-def test_pipeline_effort_passthrough(pipe):
-    # Equality-based: effort="low" must reproduce the loops=2 run exactly. An
-    # inequality check could pass while effort is silently ignored, or flake
-    # when two loop counts coincide on a few greedy tokens.
-    a = pipe("The cat", effort="low", max_new_tokens=4, do_sample=False)[0]["generated_text"]
-    b = pipe("The cat", loops=2, max_new_tokens=4, do_sample=False)[0]["generated_text"]
-    assert a == b

tests/test_provenance.py

@@ -1,38 +0,0 @@
-import hashlib
-from pathlib import Path
-
-import pytest
-import torch
-
-STAGING = Path(__file__).resolve().parents[1]
-EXPECT = {
-    "meiosis.py": "81aeb026c7ea1b7e8a7961e74c81441706b0ff5a00bd49c02099a1ff28b963c3",
-    "tokenizer.json": "d671f013ebdb06a55e48d047f12621c3311310fdcc344683d434d294a909ac51",
-    "model.safetensors": "a121c6a316e54e490918d93d3d265460d45addbdad49b8448c514e5f61232c41",
-}
-
-
-def sha256(p: Path) -> str:
-    return hashlib.sha256(p.read_bytes()).hexdigest()
-
-
-def test_artifact_shas_match_sources():
-    for name, expected in EXPECT.items():
-        assert sha256(STAGING / name) == expected, name
-
-
-def test_safetensors_is_raw_meiosis_state():
-    from safetensors.torch import load_file
-    state = load_file(str(STAGING / "model.safetensors"))
-    assert len(state) == 81
-    assert not any(k.startswith("model.") for k in state)
-    assert not any("embed_tokens" in k or "lm_head" in k for k in state)
-    assert not any(k.endswith(("rope_cos", "rope_sin", "last_loop_rms")) for k in state)
-
-
-def test_vendored_meiosis_loads_with_strict_false():
-    from meiosis import Meiosis, MeiosisConfig
-    from safetensors.torch import load_file
-    model = Meiosis(MeiosisConfig())
-    model.load_state_dict(load_file(str(STAGING / "model.safetensors")), strict=False)
-    assert sum(p.numel() for p in model.parameters()) == 5_758_572

tests/test_raw_path.py

@@ -1,31 +0,0 @@
-import sys
-from pathlib import Path
-
-import torch
-
-REPO = Path(__file__).resolve().parents[5]  # PICO/ (parents[4] is models/)
-STAGING = Path(__file__).resolve().parents[1]
-
-
-def test_generate_py_matches_space_loader_under_fixed_seed():
-    sys.path.insert(0, str(STAGING))
-    from generate import generate as staged_gen, load_model as staged_load
-    from tokenizers import Tokenizer
-
-    # Space loader (imports its own vendored meiosis from assets)
-    sys.path.insert(0, str(REPO / "spaces" / "min-spark-preview"))
-    sys.path.insert(0, str(REPO / "spaces" / "min-spark-preview" / "assets"))
-    from loader import generate as space_gen
-    from loader import load_model as space_load
-
-    tok = Tokenizer.from_file(str(STAGING / "tokenizer.json"))
-    prompt = "The meaning of life is"
-    kw = dict(loops=3, max_new=20, temperature=0.8, top_k=50, device="cpu")
-
-    torch.manual_seed(42)
-    out_a = "".join(staged_gen(staged_load(str(STAGING / "model.safetensors"), "cpu"),
-                               tok, prompt, **kw))
-    torch.manual_seed(42)
-    out_b = "".join(c for c, _n, _t in space_gen(space_load("cpu"), tok, prompt, **kw))
-
-    assert out_a == out_b

tests/test_readme.py

@@ -1,69 +0,0 @@
-import json
-from pathlib import Path
-
-STAGING = Path(__file__).resolve().parents[1]
-
-
-def test_frontmatter_present():
-    text = (STAGING / "README.md").read_text()
-    assert "license: apache-2.0" in text
-    assert "pipeline_tag: text-generation" in text
-    assert "library_name: transformers" in text
-    assert "custom_code" in text
-
-
-def test_benchmark_table_values_match_json():
-    table = (STAGING / "charts" / "benchmark_table.md").read_text()
-    # results_all_k.json lives at models/2026-07-meiosis/results/decay-p09/
-    results = Path(__file__).resolve().parents[3] / "results" / "decay-p09" / "results_all_k.json"
-    data = json.loads(results.read_text())
-    for k in ("2", "3", "4"):
-        assert f"{data[k]['blimp']['acc,none']*100:.2f}%" in table
-        assert f"{data[k]['wikitext']['byte_perplexity,none']:.4f}" in table
-
-
-def test_readme_body_inlines_table_no_placeholders():
-    readme = (STAGING / "README.md").read_text()
-    table = (STAGING / "charts" / "benchmark_table.md").read_text()
-    # No unresolved {embed}/{replace} scaffolding leaks into the card.
-    # (Precise markers only — a bare "{" would be false-positive on any
-    # legitimate code snippet with braces, e.g. {"key": ...}.)
-    assert "{embed" not in readme and "replace with:" not in readme
-    # The table content is actually inline (real rows, real values).
-    for line in table.strip().splitlines():
-        if line.startswith("|"):
-            assert line in readme, f"README is missing table row: {line}"
-
-
-def test_no_k_in_user_facing_benchmark_copy():
-    text = (STAGING / "README.md").read_text()
-    # effort names everywhere user-facing
-    assert "min-spark-low" in text and "min-spark-high" in text
-    # K loop-counts may appear ONLY in the technical note section.
-    # Gate the ENTIRE card minus the technical note block — including sections
-    # AFTER it (Provenance, License) which a "everything before technical note"
-    # check would miss.
-    tech = text.split("## Technical note")[1].split("## ")[0]
-    non_tech = text.replace("## Technical note" + tech, "")
-    # non_tech is the whole card with the technical note body removed
-    assert "K=" not in non_tech
-    assert ("K=" in tech) or ("loop" in tech.lower())
-
-
-def test_provenance_and_single_sequence_notes():
-    text = (STAGING / "README.md").read_text()
-    assert "meiosis-decay-p09" in text
-    assert "a121c6a316e54e490918d93d3d265460d45addbdad49b8448c514e5f61232c41" in text
-    assert "single-sequence" in text
-
-
-def test_license_is_apache_2():
-    lic = (STAGING / "LICENSE").read_text()
-    assert "Apache License" in lic and "Version 2.0" in lic
-
-
-def test_requirements_floor_match_installed():
-    reqs = (STAGING / "requirements.txt").read_text()
-    import transformers, tokenizers
-    assert f"transformers>={'.'.join(transformers.__version__.split('.')[:2])}" in reqs
-    assert f"tokenizers>={tokenizers.__version__.split('.')[0]}" in reqs

tests/test_remote_code.py

@@ -1,70 +0,0 @@
-import logging
-import shutil
-import tempfile
-import warnings
-from pathlib import Path
-
-import torch
-import pytest
-
-STAGING = Path(__file__).resolve().parents[1]
-# Mirrors the Hub-upload exclude set (UPLOAD.md), plus charts/deltas which are
-# unneeded for the load test and keep the temp snapshot small.
-_EXCLUDE = {"tests", "__pycache__", "make_charts.py", "benchmark_table.md",
-            "deltas.json", "charts", "UPLOAD.md", "ARCHITECTURE-VIEWER.md"}
-
-
-@pytest.fixture(scope="module")
-def snapshot():
-    with tempfile.TemporaryDirectory() as td:
-        dst = Path(td)
-        for item in STAGING.iterdir():
-            if item.name in _EXCLUDE:
-                continue
-            shutil.copytree(item, dst / item.name) if item.is_dir() else shutil.copy2(item, dst / item.name)
-        yield dst
-
-
-def load_snapshot(snapshot):
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-    with warnings.catch_warnings(record=True) as caught:
-        warnings.simplefilter("always")
-        tok = AutoTokenizer.from_pretrained(str(snapshot), trust_remote_code=True)
-        model = AutoModelForCausalLM.from_pretrained(str(snapshot), trust_remote_code=True)
-    model.eval()
-    return tok, model, caught
-
-
-def test_remote_code_loads_clean(snapshot):
-    tok, model, caught = load_snapshot(snapshot)
-    # No phantom keys, no dropped params: transformers warns on both.
-    bad = [str(w.message) for w in caught if "were not used" in str(w.message) or "not initialized" in str(w.message)]
-    assert bad == [], bad
-    # Weights actually loaded (not zero/random-init)
-    assert model.model.embed.weight.abs().sum().item() > 1e-6
-
-
-def test_remote_code_logits_match_raw(snapshot):
-    from tokenizers import Tokenizer
-    from safetensors.torch import load_file
-    from meiosis import Meiosis, MeiosisConfig
-    tok, model, _ = load_snapshot(snapshot)
-
-    raw = Meiosis(MeiosisConfig())
-    raw.load_state_dict(load_file(str(STAGING / "model.safetensors")), strict=False)
-    raw.eval()
-
-    ids = torch.tensor([[2] + tok.encode("The quick brown fox jumps over the lazy dog.")])
-    with torch.no_grad():
-        a = raw(ids, loops=3)
-        b = model(ids, effort="medium").logits
-    assert torch.allclose(a, b, atol=1e-6)
-
-
-def test_remote_code_tokenizer_matches_raw(snapshot):
-    from tokenizers import Tokenizer
-    from transformers import AutoTokenizer
-    tok = AutoTokenizer.from_pretrained(str(snapshot), trust_remote_code=True)
-    raw = Tokenizer.from_file(str(STAGING / "tokenizer.json"))
-    for text in ["hello world", "Ünïcode 你好 123", "   spaced  "]:
-        assert tok.encode(text) == raw.encode(text).ids

tests/test_tokenizer.py

@@ -1,60 +0,0 @@
-import json
-from pathlib import Path
-
-import pytest
-
-STAGING = Path(__file__).resolve().parents[1]
-
-BATTERY = [
-    "",
-    "hello world",
-    "The meaning of life is 42.",
-    "Ünïcode 你好, mixed 12345",
-    "   leading and trailing spaces   ",
-    "a\tb\nc",
-    "x" * 700,  # longer than max_seq_len; encode must still work
-]
-
-RAW_TOK = None
-HF_TOK = None
-
-
-@pytest.fixture(scope="module", autouse=True)
-def loaders():
-    global RAW_TOK, HF_TOK
-    from tokenizers import Tokenizer
-    from transformers import AutoTokenizer
-    RAW_TOK = Tokenizer.from_file(str(STAGING / "tokenizer.json"))
-    # trust_remote_code=True: config.json's auto_map marks the repo as custom
-    # code; the tokenizer is stock but without this the interactive prompt
-    # fires (and pollutes captured stdout in subprocess tests).
-    HF_TOK = AutoTokenizer.from_pretrained(str(STAGING), trust_remote_code=True)
-    return
-
-
-def test_specials_and_model_max_length():
-    tc = json.loads((STAGING / "tokenizer_config.json").read_text())
-    assert tc["pad_token"] == "<pad>" and tc["bos_token"] == "<bos>" and tc["eos_token"] == "<eos>"
-    assert tc["add_bos_token"] is False and tc["add_eos_token"] is False
-    assert tc["model_max_length"] == 512
-    assert HF_TOK.pad_token_id == 0 and HF_TOK.bos_token_id == 1 and HF_TOK.eos_token_id == 2
-    assert HF_TOK.model_max_length == 512
-
-
-def test_encode_ids_match_raw_tokenizer():
-    for text in BATTERY:
-        assert HF_TOK.encode(text) == RAW_TOK.encode(text).ids, repr(text)
-
-
-def test_decode_round_trips_byte_level():
-    for text in BATTERY:
-        if not text:
-            continue
-        ids = RAW_TOK.encode(text).ids
-        assert HF_TOK.decode(ids) == RAW_TOK.decode(ids), repr(text)
-
-
-def test_no_auto_added_specials():
-    # A bare encode must not inject <bos>/<eos> (matches training/eval).
-    assert HF_TOK.encode("hi") == RAW_TOK.encode("hi").ids
-    assert HF_TOK.encode("hi", add_special_tokens=False) == HF_TOK.encode("hi")