UPLOADERS = [
    "Lewdiculous", "QuantFactory", "brittlewis12", "RichardErkhov",
    "second-state", "mradermacher", "lmstudio-community", "MaziyarPanahi",
    "bartowski", "TheBloke", "unsloth", "mmnga", "SanctumAI",
    "OuteAI", "crusoeai", "NousResearch", "instructlab",
    "tiiuae", "stabilityai", "xtuner", "mlabonne",
    "adrienbrault", "tensorblock", "ChaoticNeutrals",
]

def extract_params(text):
    text = text.replace("_", "-")
    
    # Handle MoE notation like 30B-A3B (active params)
    moe = re.search(r'(\d+(?:\.\d+)?)[Bb]-[Aa]\d', text)
    if moe:
        return float(moe.group(1))  # Use total, not active
    
    # Standard notation: 7B, 13B, 70B
    matches = re.findall(r'(\d+(?:\.\d+)?)\s*([BbMm])(?:[^a-zA-Z]|$)', text)
    for num, unit in matches:
        val = float(num)
        if unit.upper() == 'M':
            val = val / 1000.0
        if val > 200:  # Exclude models > 200B
            continue
        return val
    return None

def pick_sibling(siblings):
    # Get GGUF files
    names = [s.get("rfilename", "") for s in siblings 
             if s.get("rfilename", "").endswith(".gguf")]
    
    def bad(n):
        # Exclude: 4/4, 4/8, 8/8 quantizations, fp16, f32, bf16, slash-containing
        return any(x in n for x in 
                   ["_4_4", "_4_8", "_8_8", "-fp16", "f16.", "f32.", "bf16.", "/"])
    
    # Priority order: Q4_K_M > Q4_K_S > Q4_0 > other Q4 > others
    for pat in ["Q4_K_M", "Q4_K_S", "Q4_0"]:
        for n in names:
            if pat in n and not bad(n):
                return n
    
    for n in names:
        if "Q4" in n and not bad(n):
            return n
    
    for n in names:
        if not bad(n) and not any(x in n for x in ["f16","f32","bf16","Q8","Q6","Q5"]):
            return n
    
    return None

def human_size(filename, params):
    if params is None:
        return "?"
    
    # Bits per byte for different quantizations
    bpb = {"Q2":0.28e9,"Q3":0.38e9,"Q4":0.50e9,
           "Q5":0.62e9,"Q6":0.75e9,"Q8":1.00e9}
    
    # Find quantization in filename
    quant = next((k for k,v in bpb.items() if k in filename), "Q4")
    bytes = params * bpb.get(quant, 0.50e9)
    
    if bytes >= 1e9:
        return f"{bytes/1e9:.1f}GB"
    else:
        return f"{bytes/1e6:.0f}MB"

# Fetch all models, cache in ./cache, output to models.txt
python3 fetch_models.py ./cache models.txt

# Get all coding models
grep "|Coding|" models.txt

# Output:
CodeLlama-7B-Instruct|Coding|TheBloke/CodeLlama-7B-Instruct-GGUF|Q4_K_M.gguf|4.2GB|9000|50000|2026-07-05
StarCoder2-7B|Coding|TheBloke/StarCoder2-7B-GGUF|Q4_K_M.gguf|4.8GB|7000|35000|2026-07-18
DeepSeek-Coder-V2|Coding|TheBloke/DeepSeek-Coder-V2-GGUF|Q4_K_M.gguf|6.7GB|5000|20000|2026-07-22

#!/bin/bash

# Parse model list and create a menu
MODEL_FILE="models.txt"

# Skip header lines
tail -n +3 "$MODEL_FILE" | while IFS='|' read -r name category repo file size likes downloads date; do
    # Only show Instruct models
    if [ "$category" = "Instruct" ]; then
        # Format for display
        printf "%-30s %10s %s\n" "$name" "$size" "[$category]"
    fi
done

def fetch_json(url, timeout=20):
    try:
        req = urllib.request.urlopen(url, timeout=timeout)
        return json.loads(req.read().decode())
    except Exception as e:
        print(f"  WARN {url[:60]}: {e}", flush=True)
        return None

# Main fetch loop
for uploader in UPLOADERS:
    print(f"\nFetching {uploader}...", flush=True)
    url = (f"https://huggingface.co/api/models"
           f"?author={uploader}&sort=likes&direction=-1&limit=500&full=true")
    data = fetch_json(url)
    if not data:
        continue
    # Process models...

def categorize(repo, filename):
    haystack = (repo + " " + filename).lower()
    
    # Stage 1: Try primary categories (first match wins)
    for cat, patterns in PRIMARY_RULES:
        for pat in patterns:
            if re.search(pat, haystack):
                return cat, False  # Matched primary, not auto
    
    # Stage 2: Auto-categorize by architecture
    for cat, patterns in AUTO_RULES:
        for pat in patterns:
            if re.search(pat, haystack):
                return cat, True  # Auto-categorized
    
    return "Auto/Other", True

def short_name(repo):
    n = repo.split("/")[-1]  # Get model name from repo
    
    # Remove common suffixes
    for s in ["-GGUF", "-gguf", "-Instruct", "-instruct",
              "-it", "-IT", "-chat", "-Chat", "-hf", "-HF"]:
        n = n.replace(s, "")
    
    return n[:36]  # Truncate to 36 chars

cp /opt/aurora/work/fetch_models.py ./fetch_models.py
chmod +x ./fetch_models.py