tests/atom_validation_harness.py

#!/usr/bin/env python3
"""
Atom Validation Harness — Tests fast_split atoms against canonical HF tokenizer patterns.

This harness:
1. Loads canonical pre_tokenizer configs from known model families
2. Tests tokenization parity between HF reference and fast_split atoms
3. Reports coverage gaps and mismatches

Usage:
    python atom_validation_harness.py --fetch-canonical  # Download configs from HF
    python atom_validation_harness.py --test-local       # Test against local fast_split
    python atom_validation_harness.py --report         # Generate coverage report
"""

import json
import os
import sys
import subprocess
import tempfile
import urllib.request
from dataclasses import dataclass
from typing import Optional, List, Dict, Tuple
from collections import defaultdict
import argparse

# ── Canonical Model Registry ─────────────────────────────────────────────

@dataclass
class CanonicalConfig:
    """A canonical tokenizer configuration representing a model family."""
    family: str                      # e.g., "llama3", "cl100k", "bert"
    model_id: str                    # HF model ID to fetch from
    atom_shape: str                 # Expected atom: A1_split, A2_class_runs, A3_cl100k, A4_deepseek, A5_byte_level, A6_script_run
    description: str
    test_cases: List[str]           # Representative test strings
    gated: bool = False             # Whether model requires auth
    alternative_models: Optional[List[str]] = None  # Fallback models if primary unavailable

# Registry of canonical patterns
CANONICAL_REGISTRY: List[CanonicalConfig] = [
    # ── A3: cl100k family (GPT-4, Claude) ──
    CanonicalConfig(
        family="cl100k_base",
        model_id="openai-community/gpt2",  # GPT-2 is byte-level, but cl100k uses same pattern
        atom_shape="A3_cl100k",
        description="OpenAI cl100k_base (GPT-4 tokenizer)",
        test_cases=[
            "Hello world",
            "don't",  # contraction
            "a1234",  # number cap
            "  hi",   # whitespace rules
            "café",  # unicode
            "a, b",   # punctuation
        ],
        alternative_models=["ggml-org/gpt-4o-2024-08-06-tokenizer"]
    ),
    
    # ── A4: DeepSeek family ──
    CanonicalConfig(
        family="deepseek_v3",
        model_id="deepseek-ai/deepseek-v3",
        atom_shape="A4_deepseek",
        description="DeepSeek-V3 Sequence tokenizer",
        test_cases=[
            "abc中def",  # CJK isolation
            "abc123",      # digits {1,3}
            "_abc",        # ASCII punct + letters
            "hello world", # word splitting
            "!!!",         # punctuation run
        ],
        gated=True,
    ),
    
    # ── A5: ByteLevel family (Llama 3, Qwen, etc.) ──
    CanonicalConfig(
        family="llama3",
        model_id="unsloth/llama-3-8b-bnb-4bit",  # Not gated
        atom_shape="A5_byte_level",
        description="Llama 3 / GPT-2 style ByteLevel with regex",
        test_cases=[
            "Hello world",
            "don't split contractions",
            "numbers 123 and 4567",
            "unicode: 世界 русский",
        ],
        alternative_models=["NousResearch/Meta-Llama-3-8B"]
    ),
    
    CanonicalConfig(
        family="qwen2",
        model_id="Qwen/Qwen2-7B",
        atom_shape="A5_byte_level",
        description="Qwen2 (similar to Llama 3)",
        test_cases=[
            "你好世界",  # Chinese
            "Hello 世界",   # Mixed
            "12345",         # Numbers
        ],
    ),
    
    CanonicalConfig(
        family="mistral",
        model_id="mistralai/Mistral-7B-v0.1",
        atom_shape="A1_split",  # Metaspace
        description="Mistral Metaspace tokenizer",
        test_cases=[
            "Hello world",
            "Test with spaces",
        ],
    ),
    
    CanonicalConfig(
        family="gemma",
        model_id="google/gemma-2-2b",
        atom_shape="A1_split",  # Metaspace
        description="Gemma Metaspace tokenizer",
        test_cases=[
            "Hello world",
        ],
        gated=True,
    ),
    
    # ── A2: BERT family ──
    CanonicalConfig(
        family="bert",
        model_id="google-bert/bert-base-uncased",
        atom_shape="A2_class_runs",
        description="BERT BertPreTokenizer",
        test_cases=[
            "Hello, world! How are you?",
            "Testing punctuation. And more...",
            "123 numbers 456",
        ],
    ),
    
    CanonicalConfig(
        family="roberta",
        model_id="FacebookAI/roberta-base",
        atom_shape="A5_byte_level",
        description="RoBERTa (ByteLevel, not BERT)",
        test_cases=[
            "Hello world",
            "Don't split",
        ],
    ),
    
    # ── A1: Simple splits ──
    CanonicalConfig(
        family="whitespace_split",
        model_id="",
        atom_shape="A1_split",
        description="WhitespaceSplit standalone",
        test_cases=["Hello world test"],
    ),
    
    # ── null: SentencePiece (T5, Llama 1/2) ──
    CanonicalConfig(
        family="t5",
        model_id="google-t5/t5-small",
        atom_shape="null",
        description="T5 (SentencePiece, no pre_tokenizer)",
        test_cases=[
            "This is a test sentence.",
            "Another example with numbers: 42",
        ],
    ),
    
    # ── UnicodeScripts ──
    CanonicalConfig(
        family="unicode_scripts",
        model_id="",
        atom_shape="A6_script_run",
        description="UnicodeScripts preprocessor (TODO in PR)",
        test_cases=["Hello مرحبا 世界"],  # Latin + Arabic + Chinese
    ),
]

# ── Test Harness Core ─────────────────────────────────────────────

class AtomValidationHarness:
    """Main test harness for validating fast_split atoms."""
    
    def __init__(self, cache_dir: str = ".tokenizers_cache"):
        self.cache_dir = cache_dir
        self.results: Dict[str, Dict] = {}
        os.makedirs(cache_dir, exist_ok=True)
        
    def fetch_tokenizer_config(self, config: CanonicalConfig) -> Optional[Dict]:
        """Fetch tokenizer.json from HF, using cache if available."""
        cache_path = os.path.join(self.cache_dir, f"{config.family}.json")
        
        # Check cache
        if os.path.exists(cache_path):
            with open(cache_path) as f:
                return json.load(f)
        
        # Try to fetch
        models_to_try = [config.model_id]
        if config.alternative_models:
            models_to_try.extend(config.alternative_models)
        
        for model_id in models_to_try:
            if not model_id:
                continue
            url = f"https://huggingface.co/{model_id}/resolve/main/tokenizer.json"
            try:
                req = urllib.request.Request(url, headers={"User-Agent": "atom-harness/1.0"})
                with urllib.request.urlopen(req, timeout=30) as resp:
                    data = json.load(resp)
                # Cache it
                with open(cache_path, "w") as f:
                    json.dump(data, f)
                return data
            except urllib.error.HTTPError as e:
                if e.code == 401:
                    print(f"  [SKIP] {model_id}: gated (401)")
                elif e.code == 404:
                    print(f"  [SKIP] {model_id}: no tokenizer.json (404)")
                else:
                    print(f"  [SKIP] {model_id}: HTTP {e.code}")
            except Exception as e:
                print(f"  [SKIP] {model_id}: {e}")
        
        return None
    
    def extract_pre_tokenizer_signature(self, tokenizer_json: Dict) -> Tuple[str, Dict]:
        """Extract canonical signature from tokenizer.json pre_tokenizer."""
        pt = tokenizer_json.get("pre_tokenizer")
        if pt is None:
            return "null", {}
        
        t = pt.get("type", "unknown")
        
        if t == "Sequence":
            parts = [p.get("type", "?") for p in pt.get("pretokenizers", [])]
            # Check for known sequences
            if parts == ["Split", "ByteLevel"]:
                return "Split+ByteLevel", pt
            if len(parts) == 4 and parts[0] == "Split" and parts[3] == "ByteLevel":
                return "DeepSeek-Sequence", pt
            return f"Sequence({','.join(parts)})", pt
        
        if t == "Split":
            pat = pt.get("pattern", {})
            pat_type = list(pat.keys())[0] if pat else "none"
            if pat_type == "Regex":
                regex = pat.get("Regex", "")
                # Classify regex
                if "N}{1,3}" in regex:
                    return "Split(Regex-cl100k)", pt
                if "\u4e00" in regex or "4e00" in regex.lower():
                    return "Split(Regex-CJK)", pt
                return f"Split(Regex:{pat_type})", pt
            return f"Split({pat_type})", pt
        
        return t, pt
    
    def reference_tokenize(self, text: str, tokenizer_json: Dict) -> List[str]:
        """Tokenize using HF tokenizers library (reference implementation)."""
        try:
            from tokenizers import Tokenizer
            # Create temp file for tokenizer.json
            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f:
                json.dump(tokenizer_json, f)
                tmp_path = f.name
            
            tok = Tokenizer.from_file(tmp_path)
            encoding = tok.encode(text)
            os.unlink(tmp_path)
            return encoding.tokens
        except ImportError:
            print("  [WARN] tokenizers library not installed, using mock")
            return [text]  # Mock fallback
        except Exception as e:
            print(f"  [WARN] Tokenization failed: {e}")
            return [text]
    
    def fast_split_tokenize(self, text: str, atom_shape: str, pre_tokenizer: Dict) -> List[str]:
        """Tokenize using fast_split atoms (TODO: integrate with Rust)."""
        # This is a placeholder - would need to call the Rust implementation
        # For now, return mock based on expected behavior
        return self._mock_fast_split(text, atom_shape, pre_tokenizer)
    
    def _mock_fast_split(self, text: str, atom_shape: str, pre_tokenizer: Dict) -> List[str]:
        """Mock fast_split behavior for testing harness structure."""
        # Simple mock implementations
        if atom_shape == "null":
            return [text]
        elif atom_shape == "A1_split":
            # Whitespace split
            return text.split()
        elif atom_shape == "A2_class_runs":
            # Bert-style: split on punctuation and whitespace
            import re
            return re.findall(r"\w+|[^\w\s]", text)
        elif atom_shape == "A5_byte_level":
            # GPT-2 style: roughly word-based
            import re
            return re.findall(r"\w+|[^\w\s]", text)
        return [text]
    
    def test_family(self, config: CanonicalConfig) -> Dict:
        """Test a single canonical family."""
        print(f"\n── Testing: {config.family} ──" + "─" * 40)
        print(f"  Expected atom: {config.atom_shape}")
        print(f"  Description: {config.description}")
        
        result = {
            "family": config.family,
            "expected_atom": config.atom_shape,
            "config_available": False,
            "signature_match": False,
            "test_passed": False,
            "errors": [],
            "details": {}
        }
        
        # Fetch config
        tokenizer_json = self.fetch_tokenizer_config(config)
        if tokenizer_json is None:
            if config.alternative_models:
                print(f"  [SKIP] All model sources unavailable (gated or no tokenizer.json)")
                result["errors"].append("All sources unavailable")
                return result
            else:
                # For families without models (like standalone configs), use embedded
                print(f"  [INFO] Using embedded mock config for {config.family}")
                tokenizer_json = {"pre_tokenizer": None}  # Mock
        
        result["config_available"] = True
        
        # Extract signature
        sig, pt_config = self.extract_pre_tokenizer_signature(tokenizer_json)
        result["signature"] = sig
        print(f"  Detected signature: {sig}")
        
        # Check if signature matches expected atom
        expected_sigs = {
            "A3_cl100k": ["Split(Regex-cl100k)"],
            "A4_deepseek": ["DeepSeek-Sequence"],
            "A5_byte_level": ["Split+ByteLevel", "ByteLevel"],
            "A2_class_runs": ["BertPreTokenizer", "Whitespace", "WhitespaceSplit"],
            "A1_split": ["Metaspace", "WhitespaceSplit", "Punctuation", "Digits"],
            "null": ["null"],
            "A6_script_run": ["UnicodeScripts"],
        }
        
        expected_list = expected_sigs.get(config.atom_shape, [])
        if sig in expected_list or any(e in sig for e in expected_list):
            result["signature_match"] = True
            print(f"  [✓] Signature matches expected atom")
        else:
            print(f"  [!] Signature mismatch: expected {expected_list}, got {sig}")
            result["errors"].append(f"Signature mismatch: {sig} not in {expected_list}")
        
        # Run test cases
        print(f"\n  Testing {len(config.test_cases)} cases:")
        all_pass = True
        for tc in config.test_cases:
            ref_tokens = self.reference_tokenize(tc, tokenizer_json)
            fast_tokens = self.fast_split_tokenize(tc, config.atom_shape, pt_config)
            
            match = ref_tokens == fast_tokens
            status = "✓" if match else "✗"
            print(f"    {status} '{tc[:30]}...' -> {len(ref_tokens)} tokens")
            if not match:
                print(f"        REF:  {ref_tokens}")
                print(f"        FAST: {fast_tokens}")
                all_pass = False
        
        result["test_passed"] = all_pass
        return result
    
    def run_all(self, families: Optional[List[str]] = None) -> None:
        """Run tests for all or selected families."""
        to_test = CANONICAL_REGISTRY
        if families:
            to_test = [c for c in CANONICAL_REGISTRY if c.family in families]
        
        print(f"\n{'='*80}")
        print(f"ATOM VALIDATION HARNESS")
        print(f"Testing {len(to_test)} canonical tokenizer families")
        print(f"{'='*80}")
        
        results = []
        for config in to_test:
            result = self.test_family(config)
            results.append(result)
            self.results[config.family] = result
        
        self.print_summary(results)
    
    def print_summary(self, results: List[Dict]) -> None:
        """Print final summary report."""
        print(f"\n\n{'='*80}")
        print("SUMMARY REPORT")
        print(f"{'='*80}")
        
        by_atom = defaultdict(list)
        for r in results:
            by_atom[r["expected_atom"]].append(r)
        
        print("\nBy Atom Shape:")
        for atom, rs in sorted(by_atom.items()):
            ok = sum(1 for r in rs if r["test_passed"])
            total = len(rs)
            print(f"  {atom:<20}: {ok}/{total} passed")
            for r in rs:
                status = "✓" if r["test_passed"] else "✗"
                avail = "Y" if r["config_available"] else "N"
                print(f"      [{status}] {r['family']:<20} (config={avail})")
        
        # Coverage gaps
        print("\n\nCOVERAGE GAPS:")
        uncovered = [r for r in results if not r["test_passed"] or not r["config_available"]]
        if uncovered:
            for r in uncovered:
                reason = "unavailable" if not r["config_available"] else "mismatch"
                print(f"  - {r['family']}: {reason} (expected {r['expected_atom']})")
        else:
            print("  None - all canonical families covered!")
        
        # Unique patterns count
        unique_sigs = set(r.get("signature", "unknown") for r in results if r["config_available"])
        print(f"\n\nUNIQUE SIGNATURES DETECTED: {len(unique_sigs)}")
        for sig in sorted(unique_sigs):
            families = [r["family"] for r in results if r.get("signature") == sig]
            print(f"  - {sig:<40} ({', '.join(families)})")

# ── CLI ─────────────────────────────────────────────────────────────
def main():
    parser = argparse.ArgumentParser(description="Atom Validation Harness")
    parser.add_argument("--fetch-canonical", action="store_true", help="Fetch canonical configs")
    parser.add_argument("--test-local", action="store_true", help="Test against local fast_split")
    parser.add_argument("--report", action="store_true", help="Generate coverage report")
    parser.add_argument("--families", nargs="+", help="Test only specific families")
    parser.add_argument("--cache-dir", default=".tokenizers_cache", help="Cache directory")
    
    args = parser.parse_args()
    
    harness = AtomValidationHarness(cache_dir=args.cache_dir)
    
    if args.report:
        # Just print the registry for documentation
        print("# Canonical Tokenizer Registry\n")
        for c in CANONICAL_REGISTRY:
            print(f"## {c.family}")
            print(f"- Expected atom: `{c.atom_shape}`")
            print(f"- Description: {c.description}")
            print(f"- Primary model: `{c.model_id}`")
            print(f"- Test cases: {c.test_cases}")
            print()
        return
    
    # Default: run tests
    harness.run_all(families=args.families)

if __name__ == "__main__":
    main()