Upload folder using huggingface_hub

scrape_analysis/analyze.py

@@ -0,0 +1,274 @@
+#!/usr/bin/env python3
+"""
+Analyze scraped tokenizer.json pre_tokenizers and classify each against the
+PR's atom FSM shapes. Report which patterns are covered and which need hand-unroll.
+
+PR atom FSM shapes (from fast_split/src/fsm.rs + TAG_CLASSIFY_SPEC.md):
+  A1. fsm_split<DELIM,BEHAVIOR>       — Split delimiter (Removed/Isolated/Contiguous/MergedPrev/MergedNext)
+                                        covers: WhitespaceSplit, Punctuation, Digits, Metaspace, CharDelimiterSplit, Split-literal
+  A2. fsm_class_runs<DROP,ISOLATE,SPLIT> — class-change cut
+                                        covers: Whitespace, Bert
+  A3. fsm_cl100k                       — cl100k/o200k 7-rule scalar FSM
+  A4. fsm_deepseek                     — deepseek-v3 Sequence (digits{1,3} → CJK → big regex)
+  A5. fsm_byte_level                   — GPT-2/ByteLevel (TODO in PR)
+  A6. fsm_script_run                   — UnicodeScripts (TODO in PR)
+  OUT. Split(regex)                    — runtime regex, feature-gated escape hatch (NOT an atom)
+"""
+import json, os, re, sys
+from collections import Counter, defaultdict
+
+IN = os.path.join(os.path.dirname(__file__), "scrape_hf.jsonl")
+
+# ── Canonical regex patterns we recognize ──────────────────────────────────────
+# cl100k_base / o200k_base (GPT-4 / GPT-4o) pretokenizer regex:
+CL100K_REGEX = r"""'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
+O200K_REGEX = r"""[^\r\n\p{L}\p{N}]?[\p{Lu}\p{Lt}\p{Lm}\p{Lo}\p{M}]*[\p{Ll}\p{Lm}\p{Lo}\p{M}]+(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{Lu}[\p{Lm}\p{Lo}\p{M}]*(?i:'s|'t|'re|'ve|'m|'ll|'d)?|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
+# GPT-2 / ByteLevel regex (use_regex=true):
+GPT2_REGEX = r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
+# Deepseek-v3 big-regex alt-3:
+DS_BIGREGEX = r"""[!"#$%&'()*+,\-./:;<=>?@[\]^_`{|}~][A-Za-z]+|[^\r\n\p{L}\p{P}\p{S}]?[\p{L}\p{M}]+| ?[\p{P}\p{S}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
+# Qwen / Llama3 / Mistral-style Split regex (the common "ByteLevel with regex" split):
+# This is the GPT-2-like regex but with \p{N}{1,2} or \p{N}{1,3} variations:
+LLAMA3_REGEX = r"""(?i:'s|'t|'re|'ve|'m|'ll|'d)|[^\r\n\p{L}\p{N}]?\p{L}+|\p{N}{1,3}| ?[^\s\p{L}\p{N}]+[\r\n]*|\s*[\r\n]+|\s+(?!\S)|\s+"""
+
+def normalize_regex(r):
+    """Normalize a regex string for comparison (strip whitespace, collapse)."""
+    if r is None:
+        return None
+    r = r.strip()
+    # collapse internal whitespace
+    r = re.sub(r'\s+', '', r)
+    return r
+
+# Pre-compute normalized known regexes
+KNOWN = {
+    "cl100k": normalize_regex(CL100K_REGEX),
+    "o200k": normalize_regex(O200K_REGEX),
+    "gpt2": normalize_regex(GPT2_REGEX),
+    "deepseek_big": normalize_regex(DS_BIGREGEX),
+    "llama3": normalize_regex(LLAMA3_REGEX),
+}
+
+# ── Classification ─────────────────────────────────────────────────────────────
+
+def classify_pre_tokenizer(pt, norm=None):
+    """
+    Classify a pre_tokenizer JSON object.
+    Returns (atom_shape, canonical_signature, details).
+    atom_shape is one of:
+      'A1_split', 'A2_class_runs', 'A3_cl100k', 'A4_deepseek', 'A5_byte_level',
+      'A6_script_run', 'A1_split_regex', 'SEQUENCE', 'null', 'UNKNOWN'
+    canonical_signature: a string that uniquely identifies the pre_tokenizer pattern.
+    """
+    if pt is None:
+        return ("null", "null", "no pre_tokenizer (SentencePiece or raw)")
+    t = pt.get("type")
+    sig_parts = []
+    if t == "Sequence":
+        subs = pt.get("pretokenizers", [])
+        sub_results = []
+        for s in subs:
+            sub_atom, sub_sig, sub_det = classify_pre_tokenizer(s)
+            sub_results.append((sub_atom, sub_sig, s.get("type")))
+        # Classify the whole sequence
+        sub_types = [s.get("type") for s in subs]
+        sub_atoms = [r[0] for r in sub_results]
+        sub_sigs = [r[1] for r in sub_results]
+        sig = "Seq[" + ",".join(sub_sigs) + "]"
+        # Heuristics for known sequences
+        # Deepseek: [Split(N{1,3}), Split(CJK), Split(bigregex), ByteLevel]
+        if len(subs) == 4 and sub_types == ["Split","Split","Split","ByteLevel"]:
+            r0 = subs[0].get("pattern",{}).get("Regex","")
+            r1 = subs[1].get("pattern",{}).get("Regex","")
+            r2 = subs[2].get("pattern",{}).get("Regex","")
+            if "N}" in r0 and ("4e00" in r1.lower() or "\\u4e00" in r1) and "p{P}" in r2:
+                return ("A4_deepseek", sig, "deepseek-v3 Sequence")
+            # Check if r2 is the deepseek big regex
+            nr2 = normalize_regex(r2)
+            if nr2 == KNOWN["deepseek_big"]:
+                return ("A4_deepseek", sig, "deepseek-v3 Sequence (big regex match)")
+        # Llama3/Qwen/Mistral: [Split(cl100k-like regex), ByteLevel]
+        if len(subs) == 2 and sub_types == ["Split","ByteLevel"]:
+            r0 = subs[0].get("pattern",{}).get("Regex","")
+            nr0 = normalize_regex(r0)
+            if nr0 == KNOWN["cl100k"] or nr0 == KNOWN["llama3"]:
+                return ("A5_byte_level", sig, "ByteLevel + cl100k-regex Split (llama3/qwen pattern)")
+            # generic regex + bytelevel
+            return ("A5_byte_level", sig, f"ByteLevel + Split(regex {r0[:40]}...)")
+        # XLM-R: [WhitespaceSplit, Metaspace]
+        if len(subs) == 2 and sub_types == ["WhitespaceSplit","Metaspace"]:
+            return ("A1_split", sig, "WhitespaceSplit + Metaspace (A1 ×2)")
+        # Sequence of all A1-compatible splits
+        if all(a in ("A1_split","A1_split_regex") for a in sub_atoms):
+            if all(a == "A1_split" for a in sub_atoms):
+                return ("A1_split", sig, "Sequence of A1-compatible splits")
+            return ("A1_split_regex", sig, "Sequence with regex Split(s)")
+        # Mixed
+        return ("SEQUENCE", sig, f"Seq types={sub_types} atoms={sub_atoms}")
+    elif t == "WhitespaceSplit":
+        return ("A1_split", "WhitespaceSplit", "fsm_split<WS, Removed>")
+    elif t == "Whitespace":
+        return ("A2_class_runs", "Whitespace", "fsm_class_runs<WS,0,WORD>")
+    elif t == "BertPreTokenizer":
+        return ("A2_class_runs", "BertPreTokenizer", "fsm_class_runs<WS,PUNCT,0>")
+    elif t == "Punctuation":
+        return ("A1_split", "Punctuation", "fsm_split<PUNCT, Isolated>")
+    elif t == "Digits":
+        beh = pt.get("behavior", "Contiguous")
+        return ("A1_split", f"Digits({beh})", f"fsm_split<NUMERIC, {beh}>")
+    elif t == "Metaspace":
+        return ("A1_split", "Metaspace", "fsm_split<Space→▁, MergedWithNext>")
+    elif t == "ByteLevel":
+        ur = pt.get("use_regex", False)
+        if ur:
+            return ("A5_byte_level", "ByteLevel(use_regex=true)", "fsm_byte_level (GPT-2 regex)")
+        else:
+            return ("A5_byte_level", "ByteLevel(use_regex=false)", "fsm_byte_level (no regex)")
+    elif t == "Split":
+        pat = pt.get("pattern", {})
+        beh = pt.get("behavior", "?")
+        inv = pt.get("invert", False)
+        pat_kind = list(pat.keys())[0] if pat else "none"
+        pat_val = list(pat.values())[0] if pat else ""
+        if pat_kind == "Regex":
+            nr = normalize_regex(pat_val)
+            if nr == KNOWN["cl100k"]:
+                return ("A3_cl100k", f"Split(cl100k:{beh})", "cl100k regex Split")
+            if nr == KNOWN["o200k"]:
+                return ("A3_cl100k", f"Split(o200k:{beh})", "o200k regex Split (A3 variant)")
+            if nr == KNOWN["gpt2"]:
+                return ("A5_byte_level", f"Split(gpt2:{beh})", "GPT-2 regex Split (A5)")
+            if nr == KNOWN["deepseek_big"]:
+                return ("A4_deepseek", f"Split(ds_big:{beh})", "deepseek big regex Split")
+            # Unknown regex
+            return ("A1_split_regex", f"Split(Regex:{beh}:{pat_val[:50]})", f"regex Split, behavior={beh}")
+        elif pat_kind == "String":
+            return ("A1_split", f"Split(String:{beh}:{pat_val})", "literal Split (CharDelimiterSplit family)")
+        elif pat_kind == "FairSeq":
+            return ("UNKNOWN", f"Split(FairSeq:{beh})", "FairSeq pattern — not an atom")
+        else:
+            return ("UNKNOWN", f"Split({pat_kind}:{beh})", f"unknown Split pattern type {pat_kind}")
+    elif t == "UnicodeScripts":
+        return ("A6_script_run", "UnicodeScripts", "fsm_script_run (TODO in PR)")
+    elif t == "CharDelimiterSplit":
+        ch = pt.get("delimiter", "?")
+        return ("A1_split", f"CharDelimiterSplit({ch})", "byte compare, no tag")
+    elif t == "FixedLength":
+        return ("UNKNOWN", "FixedLength", "positional — rides char_start bitplane, not an atom FSM")
+    elif t == "Symbols":
+        return ("UNKNOWN", "Symbols", "Symbols pretokenizer — not in atom design")
+    elif t == "Sequence":
+        return classify_pre_tokenizer(pt, norm)  # handled above
+    else:
+        return ("UNKNOWN", f"{t}", f"unknown pretokenizer type: {t}")
+
+# ── Main ───────────────────────────────────────────────────────────────────────
+
+def main():
+    records = [json.loads(l) for l in open(IN)]
+    print(f"Loaded {len(records)} scraped records")
+
+    # Classify each
+    results = []
+    for r in records:
+        pt = r.get("pre_tokenizer")
+        norm = r.get("normalizer")
+        if r.get("error"):
+            continue
+        atom, sig, detail = classify_pre_tokenizer(pt, norm)
+        results.append({
+            "id": r["id"],
+            "downloads": r.get("downloads", 0),
+            "atom": atom,
+            "sig": sig,
+            "detail": detail,
+            "pre_tokenizer": pt,
+            "normalizer": norm,
+        })
+
+    print(f"Classified {len(results)} models (excluding errors)\n")
+
+    # Aggregate by canonical signature
+    sig_counts = Counter()
+    sig_examples = defaultdict(list)
+    sig_atom = {}
+    sig_downloads = defaultdict(int)
+    for r in results:
+        sig_counts[r["sig"]] += 1
+        sig_examples[r["sig"]].append(r["id"])
+        sig_atom[r["sig"]] = r["atom"]
+        sig_downloads[r["sig"]] += r["downloads"]
+
+    # Print the full ranked table
+    print("=" * 120)
+    print(f"{'CANONICAL PRE_TOKENIZER SIGNATURE':<55} {'ATOM':<18} {'COUNT':>6} {'∑DL':>12}  EXAMPLES")
+    print("=" * 120)
+    for sig, cnt in sig_counts.most_common():
+        atom = sig_atom[sig]
+        dl = sig_downloads[sig]
+        exs = sig_examples[sig][:3]
+        ex_str = " | ".join(exs)
+        if len(ex_str) > 40:
+            ex_str = ex_str[:37] + "..."
+        print(f"{sig:<55} {atom:<18} {cnt:>6} {dl:>12,}  {ex_str}")
+    print("=" * 120)
+    print(f"TOTAL distinct signatures: {len(sig_counts)}")
+    print(f"TOTAL models classified: {len(results)}")
+
+    # Atom coverage summary
+    print("\n" + "=" * 80)
+    print("ATOM COVERAGE SUMMARY")
+    print("=" * 80)
+    atom_counts = Counter(r["atom"] for r in results)
+    atom_dl = defaultdict(int)
+    for r in results:
+        atom_dl[r["atom"]] += r["downloads"]
+    for atom, cnt in atom_counts.most_common():
+        dl = atom_dl[atom]
+        print(f"  {atom:<20} models={cnt:>5}  ∑downloads={dl:>13,}")
+
+    # Patterns NOT covered by atoms
+    print("\n" + "=" * 80)
+    print("PATTERNS NOT COVERED BY ATOMS (need hand-unroll or escape hatch)")
+    print("=" * 80)
+    uncovered = [r for r in results if r["atom"] in ("UNKNOWN", "A1_split_regex", "SEQUENCE")]
+    unc_sigs = Counter(r["sig"] for r in uncovered)
+    unc_atom = defaultdict(set)
+    for r in uncovered:
+        unc_atom[r["atom"]].add(r["sig"])
+    print(f"\nBy atom category:")
+    for atom in sorted(unc_atom.keys()):
+        sigs = unc_atom[atom]
+        total_models = sum(sig_counts[s] for s in sigs)
+        total_dl = sum(sig_downloads[s] for s in sigs)
+        print(f"\n  [{atom}]  {len(sigs)} distinct signatures, {total_models} models, ∑{total_dl:,} downloads")
+        for sig in sorted(sigs, key=lambda s: sig_downloads[s], reverse=True)[:20]:
+            cnt = sig_counts[sig]
+            dl = sig_downloads[sig]
+            exs = sig_examples[sig][:2]
+            print(f"    {sig:<60} {cnt:>4} models  ∑{dl:>10,}  e.g. {exs[0]}")
+
+    # The key question: how many unique "important" patterns need hand-unroll?
+    print("\n" + "=" * 80)
+    print("UNIQUE PATTERNS NEEDING HAND-UNROLL")
+    print("=" * 80)
+    # "Important" = either appears in >1 model OR >10K downloads
+    important_uncovered = []
+    for sig, cnt in unc_sigs.items():
+        dl = sig_downloads[sig]
+        atom = sig_atom[sig]
+        if cnt > 1 or dl > 10000:
+            important_uncovered.append((sig, atom, cnt, dl, sig_examples[sig][:3]))
+    important_uncovered.sort(key=lambda x: x[3], reverse=True)
+    print(f"\n{len(important_uncovered)} distinct signatures with >1 model OR >10K downloads:")
+    for sig, atom, cnt, dl, exs in important_uncovered:
+        print(f"  [{atom}] {sig[:65]:<65} {cnt:>3}x  ∑{dl:>10,}  {exs[0]}")
+
+    # Save full results
+    out_path = os.path.join(os.path.dirname(__file__), "classification.json")
+    with open(out_path, "w") as f:
+        json.dump(results, f, indent=2, ensure_ascii=False, default=str)
+    print(f"\nFull classification saved to {out_path}")
+
+if __name__ == "__main__":
+    main()

scrape_analysis/model_list.json

@@ -0,0 +1 @@
+[]

scrape_analysis/scrape_hf.py

@@ -0,0 +1,276 @@
+#!/usr/bin/env python3
+"""
+Scrape HuggingFace Hub for transformers-compatible models, fetch tokenizer.json
+for each (streaming only pre_tokenizer + normalizer, not the vocab), dump to JSONL.
+Uses cached HF token for higher rate limits.
+"""
+import json, os, sys, time, urllib.request, urllib.error, concurrent.futures, threading
+from collections import Counter
+
+BASE = "https://huggingface.co/api/models"
+RESOLVE = "https://huggingface.co/{mid}/resolve/main/tokenizer.json"
+OUT = os.path.join(os.path.dirname(__file__), "scrape_hf.jsonl")
+MODELS_OUT = os.path.join(os.path.dirname(__file__), "model_list.json")
+
+TARGET = 10000
+MAX_WORKERS = 40
+TIMEOUT = 15
+
+# Load HF token from cache for auth  
+def get_hf_token():
+    tok_path = os.path.expanduser("~/.cache/huggingface/token")
+    try:
+        with open(tok_path) as f:
+            return f.read().strip()
+    except:
+        return None
+
+HF_TOKEN = get_hf_token()
+
+def api_headers():
+    h = {"User-Agent": "hf-scrape/1.0"}
+    if HF_TOKEN:
+        h["Authorization"] = f"Bearer {HF_TOKEN}"
+    return h
+
+# ── streaming pre_tokenizer extractor ──────────────────────────────────────────
+
+def find_key_value(buf, key):
+    needle = b'"' + key.encode() + b'"'
+    idx = buf.find(needle)
+    if idx == -1:
+        return "NOT_FOUND", -1
+    i = idx + len(needle)
+    while i < len(buf) and buf[i:i+1] in (b' ', b'\t', b'\n', b'\r', b':'):
+        i += 1
+    if i >= len(buf):
+        return "INCOMPLETE", idx
+    start = i
+    b0 = buf[i]
+    if b0 in (0x6E, 0x74, 0x66):  # null/true/false
+        j = i
+        while j < len(buf) and buf[j] not in (b',', b'}', b']', 0x20, 0x09, 0x0A, 0x0D):
+            j += 1
+        if j < len(buf):
+            return buf[start:j].decode('utf-8', errors='replace'), j
+        return "INCOMPLETE", idx
+    if b0 == 0x22:  # string
+        j = i + 1
+        esc = False
+        while j < len(buf):
+            if esc:
+                esc = False
+            elif buf[j] == 0x5C:
+                esc = True
+            elif buf[j] == 0x22:
+                return buf[start:j+1].decode('utf-8', errors='replace'), j+1
+            j += 1
+        return "INCOMPLETE", idx
+    if (0x30 <= b0 <= 0x39) or b0 == 0x2D:  # number
+        j = i
+        while j < len(buf) and buf[j] not in (b',', b'}', b']', 0x20, 0x09, 0x0A, 0x0D):
+            j += 1
+        if j < len(buf):
+            return buf[start:j].decode('utf-8', errors='replace'), j
+        return "INCOMPLETE", idx
+    # object/array -- brace-match
+    depth = 0
+    in_str = False
+    esc = False
+    while i < len(buf):
+        b = buf[i]
+        if in_str:
+            if esc:
+                esc = False
+            elif b == 0x5C:
+                esc = True
+            elif b == 0x22:
+                in_str = False
+        else:
+            if b == 0x22:
+                in_str = True
+            elif b in (0x7B, 0x5B):
+                depth += 1
+            elif b in (0x7D, 0x5D):
+                depth -= 1
+                if depth == 0:
+                    return buf[start:i+1].decode('utf-8', errors='replace'), i+1
+        i += 1
+    return "INCOMPLETE", idx
+
+def stream_pre_tokenizer(url, timeout=TIMEOUT, max_bytes=3_000_000):
+    req = urllib.request.Request(url, headers={"User-Agent": "hf-scrape/1.0"})
+    out = {}
+    for attempt in range(3):
+        try:
+            resp = urllib.request.urlopen(req, timeout=timeout)
+            buf = b""
+            have = set()
+            wanted = {"pre_tokenizer", "normalizer"}
+            try:
+                while True:
+                    chunk = resp.read(65536)
+                    if not chunk:
+                        break
+                    buf += chunk
+                    for key in wanted:
+                        if key not in have:
+                            val, _ = find_key_value(buf, key)
+                            if val == "NOT_FOUND":
+                                continue
+                            if val == "INCOMPLETE":
+                                continue
+                            try:
+                                out[key] = json.loads(val) if val != "null" else None
+                                have.add(key)
+                            except:
+                                pass
+                    if have == wanted:
+                        break
+                    if b'"model"' in buf and have:
+                        for key in wanted:
+                            if key not in have:
+                                out[key] = None
+                                have.add(key)
+                        break
+                    if len(buf) > max_bytes:
+                        break
+            finally:
+                resp.close()
+            break
+        except urllib.error.HTTPError as e:
+            if e.code == 429 and attempt < 2:
+                time.sleep(3 * (attempt+1))
+                continue
+            out["error"] = f"HTTP {e.code}"
+            break
+        except Exception as e:
+            out["error"] = str(e)[:200]
+            break
+    return out
+
+# ── model list scraping ────────────────────────────────────────────────────────
+
+def fetch_model_list(target):
+    models = []
+    seen = set()
+    offset = 0
+    limit = 500  # larger pages with auth
+    url_base = f"{BASE}?library=transformers&sort=downloads&direction=-1&limit={limit}"
+    print(f"Fetching model list with AUTH (target={target})...", flush=True)
+    consecutive_fails = 0
+    while len(models) < target:
+        page_url = f"{url_base}&offset={offset}"
+        batch = []
+        got = False
+        for attempt in range(5):
+            try:
+                req = urllib.request.Request(page_url, headers=api_headers())
+                with urllib.request.urlopen(req, timeout=30) as resp:
+                    batch = json.loads(resp.read())
+                got = True
+                break
+            except urllib.error.HTTPError as e:
+                if e.code == 429:
+                    wait = min(60, 5 * (attempt+1))
+                    print(f"  429 at offset={offset}, waiting {wait}s", flush=True)
+                    time.sleep(wait)
+                    continue
+                print(f"  HTTP {e.code} at offset={offset}", flush=True)
+                break
+            except Exception as e:
+                if attempt < 4:
+                    time.sleep(2 * (attempt+1))
+                    continue
+                print(f"  FAILED offset={offset}: {e}", flush=True)
+                break
+        if not got or not batch:
+            consecutive_fails += 1
+            if consecutive_fails >= 3:
+                print(f"  3 consecutive fails, stopping", flush=True)
+                break
+            offset += limit
+            continue
+        consecutive_fails = 0
+        for m in batch:
+            mid = m["id"] if isinstance(m, dict) else m
+            if mid in seen:
+                continue
+            seen.add(mid)
+            models.append({
+                "id": mid,
+                "downloads": m.get("downloads", 0) if isinstance(m, dict) else 0,
+                "likes": m.get("likes", 0) if isinstance(m, dict) else 0,
+            })
+            if len(models) >= target:
+                break
+        offset += limit
+        if len(models) >= target or offset % 5000 == 0:
+            print(f"  fetched {len(models)} models (offset={offset})", flush=True)
+        time.sleep(0.05)
+    return models[:target]
+
+# ── main ───────────────────────────────────────────────────────────────────────
+
+def main():
+    t0 = time.time()
+    models = fetch_model_list(TARGET)
+    print(f"\nGot {len(models)} model IDs in {time.time()-t0:.1f}s", flush=True)
+    with open(MODELS_OUT, "w") as f:
+        json.dump(models, f)
+
+    total = len(models)
+    results = []
+    done = [0]
+    lock = threading.Lock()
+
+    def fetch_one(m):
+        url = RESOLVE.format(mid=m["id"])
+        out = stream_pre_tokenizer(url)
+        rec = {
+            "id": m["id"],
+            "downloads": m.get("downloads", 0),
+            "likes": m.get("likes", 0),
+            "pre_tokenizer": out.get("pre_tokenizer"),
+            "normalizer": out.get("normalizer"),
+            "error": out.get("error"),
+        }
+        with lock:
+            done[0] += 1
+            if done[0] % 500 == 0:
+                print(f"  progress: {done[0]}/{total}", flush=True)
+        return rec
+
+    print(f"\nFetching tokenizer.json for {total} models with {MAX_WORKERS} workers...", flush=True)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=MAX_WORKERS) as ex:
+        futures = {ex.submit(fetch_one, m): m for m in models}
+        for f in concurrent.futures.as_completed(futures):
+            try:
+                results.append(f.result())
+            except Exception as e:
+                m = futures[f]
+                results.append({"id": m["id"], "error": str(e)[:200]})
+
+    # Sort by downloads desc
+    results.sort(key=lambda r: r.get("downloads", 0), reverse=True)
+    with open(OUT, "w") as f:
+        for r in results:
+            f.write(json.dumps(r, ensure_ascii=False) + "\n")
+
+    elapsed = time.time() - t0
+    ok = sum(1 for r in results if r.get("pre_tokenizer") is not None)
+    null_pt = sum(1 for r in results if r.get("pre_tokenizer") is None and not r.get("error"))
+    err = sum(1 for r in results if r.get("error"))
+    err404 = sum(1 for r in results if r.get("error") == "HTTP 404")
+    err401 = sum(1 for r in results if r.get("error") == "HTTP 401")
+    print(f"\n=== DONE in {elapsed:.1f}s ===", flush=True)
+    print(f"  models listed: {len(models)}", flush=True)
+    print(f"  had tokenizer.json (no 404): {len(results) - err404}", flush=True)
+    print(f"  404 (no tokenizer.json): {err404}", flush=True)
+    print(f"  401 (gated): {err401}", flush=True)
+    print(f"  pre_tokenizer != None: {ok}", flush=True)
+    print(f"  pre_tokenizer == null: {null_pt}", flush=True)
+    print(f"  output: {OUT}", flush=True)
+
+if __name__ == "__main__":
+    main()