Upload folder using huggingface_hub

packages/eval-entity-resolver/src/eval_entity_resolver/__init__.py

@@ -1,5 +1,6 @@
 from eval_entity_resolver.alias_store import AliasStore
 from eval_entity_resolver.canonical_store import CanonicalStore
+from eval_entity_resolver.display import humanize_model_slug
 from eval_entity_resolver.eee import clean_eval_name, extract_metric
 from eval_entity_resolver.models import ResolutionResult, ResolverConfig
 from eval_entity_resolver.resolver import Resolver
@@ -12,4 +13,5 @@ __all__ = [
     "ResolutionResult",
     "clean_eval_name",
     "extract_metric",
+    "humanize_model_slug",
 ]

packages/eval-entity-resolver/src/eval_entity_resolver/display.py

@@ -0,0 +1,183 @@
+"""Display-name humanization for canonical model slugs.
+
+Single source of truth for converting machine slugs (`gpt-4o-2024-05-13`) into
+human-friendly display names (`GPT-4o (2024-05-13)`). Used by refresh scripts
+and the seed migration; consumers (frontend, API) should NOT re-humanize but
+read `canonical_models.display_name` directly.
+
+Rules in priority order:
+1. Strip org prefix (`openai/gpt-5` -> `gpt-5`).
+2. Strip and parenthesize a trailing date suffix:
+   - `-YYYY-MM-DD` -> ` (YYYY-MM-DD)`
+   - `-YYYYMMDD`  -> ` (YYYY-MM-DD)`
+   - `-MMDD` (4-digit) -> ` (MMDD)`
+3. Per-token formatting:
+   - Known acronyms render uppercase (`gpt` -> `GPT`).
+   - Mixed-case overrides apply (`moe` -> `MoE`).
+   - Param sizes uppercase the unit (`7b` -> `7B`, `a22b` -> `A22B`,
+     `8x7b` -> `8x7B`, `30m` -> `30M`).
+   - Number+letter version tags preserve case (`4o` -> `4o`).
+   - O-series stays lowercase (`o1`, `o3`).
+   - Vendor-name overrides (`deepseek` -> `DeepSeek`).
+   - Default: capitalize first letter.
+4. Glue an acronym token to the next token with a hyphen when the next
+   token is a bare version number (digits + optional `.NN` + optional
+   single non-size letter): `GPT 5 Mini` -> `GPT-5 Mini`,
+   `GPT 4o ...` -> `GPT-4o ...`. Skipped when the next token is a param
+   size like `7B`.
+"""
+
+from __future__ import annotations
+
+import re
+
+ACRONYMS: frozenset[str] = frozenset(
+    {
+        "gpt",
+        "glm",
+        "llm",
+        "vl",
+        "vlm",
+        "qvq",
+        "qwq",
+        "mt",
+        "vit",
+        "clip",
+        "dit",
+        "hf",
+        "ocr",
+        "tts",
+        "asr",
+        "moe",
+        "mlp",
+        "rlhf",
+    }
+)
+
+# Tokens whose canonical rendering is mixed case rather than ALL CAPS.
+CASE_OVERRIDES: dict[str, str] = {
+    "moe": "MoE",
+    "vit": "ViT",
+    "dit": "DiT",
+}
+
+# Vendor / family tokens whose canonical rendering doesn't match a simple
+# capitalize() — e.g., `deepseek` should display as `DeepSeek`. Keep the
+# list short; this is for tokens the auto-rule mangles, not a general
+# branding registry.
+TOKEN_OVERRIDES: dict[str, str] = {
+    "deepseek": "DeepSeek",
+    "openai": "OpenAI",
+    "stepfun": "StepFun",
+    "moonshotai": "MoonshotAI",
+    "mistralai": "MistralAI",
+}
+
+# Suffixes treated as parameter-count units, NOT version letters. When a
+# token like `7b` appears after an acronym, we do NOT hyphen-glue it.
+_SIZE_SUFFIXES: frozenset[str] = frozenset({"b", "m", "k"})
+
+
+def humanize_model_slug(slug: str) -> str:
+    """Render a model slug as a human display name.
+
+    Accepts a bare slug (`gpt-4o-2024-05-13`) or a full canonical id
+    (`openai/gpt-4o-2024-05-13`); the org prefix is dropped.
+    """
+    if not slug:
+        return ""
+    if "/" in slug:
+        slug = slug.split("/", 1)[1]
+
+    slug, suffix = _strip_date_suffix(slug)
+
+    tokens = slug.split("-")
+    formatted = [_format_token(t) for t in tokens]
+
+    out: list[str] = []
+    i = 0
+    while i < len(formatted):
+        cur_lower = tokens[i].lower()
+        if (
+            i + 1 < len(formatted)
+            and cur_lower in ACRONYMS
+            and _is_version_token(tokens[i + 1])
+        ):
+            out.append(f"{formatted[i]}-{formatted[i + 1]}")
+            i += 2
+        else:
+            out.append(formatted[i])
+            i += 1
+
+    return " ".join(out) + suffix
+
+
+def _strip_date_suffix(slug: str) -> tuple[str, str]:
+    """Pop a trailing date or 4-digit code; return (slug_without, ' (suffix)').
+
+    Order matters: more specific patterns first, since a partial match
+    against a less-specific pattern would mis-render (e.g. `2025` as a
+    bare 4-digit code when it's actually the year half of `2025-08`).
+    """
+    # Full ISO date: `-YYYY-MM-DD`
+    m = re.search(r"-(20\d{2}-\d{2}-\d{2})$", slug)
+    if m:
+        return slug[: m.start()], f" ({m.group(1)})"
+    # Compact date: `-YYYYMMDD`
+    m = re.search(r"-(20\d{6})$", slug)
+    if m:
+        d = m.group(1)
+        return slug[: m.start()], f" ({d[:4]}-{d[4:6]}-{d[6:8]})"
+    # Year-month: `-YYYY-MM` (e.g. `gpt-5-2025-08`)
+    m = re.search(r"-(20\d{2})-(\d{2})$", slug)
+    if m:
+        return slug[: m.start()], f" ({m.group(1)}-{m.group(2)})"
+    # Cohere convention: `-MM-YYYY` (e.g. `command-r-08-2024`).
+    # Render as `(YYYY-MM)` for ISO-ordered display.
+    m = re.search(r"-(\d{2})-(20\d{2})$", slug)
+    if m:
+        return slug[: m.start()], f" ({m.group(2)}-{m.group(1)})"
+    # Bare 4-digit code: `-NNNN` (e.g. `grok-4-0709`, `kimi-k2-0711`).
+    m = re.search(r"-(\d{4})$", slug)
+    if m:
+        return slug[: m.start()], f" ({m.group(1)})"
+    return slug, ""
+
+
+def _format_token(tok: str) -> str:
+    if not tok:
+        return tok
+    low = tok.lower()
+    if low in CASE_OVERRIDES:
+        return CASE_OVERRIDES[low]
+    if low in ACRONYMS:
+        return low.upper()
+    if low in TOKEN_OVERRIDES:
+        return TOKEN_OVERRIDES[low]
+    # Param size: 7b, 70b, 1.5b, 30m
+    if re.fullmatch(r"\d+(?:\.\d+)?[bmk]", low):
+        return low[:-1] + low[-1].upper()
+    # MoE active-expert form: a22b, a3b
+    if re.fullmatch(r"a\d+(?:\.\d+)?b", low):
+        return "A" + low[1:-1] + "B"
+    # MxNb: 8x7b -> 8x7B
+    if re.fullmatch(r"\d+x\d+(?:\.\d+)?b", low):
+        return low[:-1] + "B"
+    # Number followed by a single lowercase letter that's NOT a size suffix:
+    # version tags like `4o`, `5o` — keep as-is.
+    if re.fullmatch(r"\d+(?:\.\d+)?[a-z]", low) and low[-1] not in _SIZE_SUFFIXES:
+        return low
+    # O-series: o1, o3, o4
+    if re.fullmatch(r"o\d+", low):
+        return low
+    # Default: capitalize first letter, preserve rest.
+    return tok[0].upper() + tok[1:] if tok[0].isalpha() else tok
+
+
+def _is_version_token(tok: str) -> bool:
+    """True if `tok` looks like a version (e.g. `5`, `4.5`, `4o`) and not
+    a parameter size (`7b`, `70m`)."""
+    m = re.fullmatch(r"(\d+(?:\.\d+)?)([a-z]?)", tok.lower())
+    if not m:
+        return False
+    return m.group(2) not in _SIZE_SUFFIXES

src/eval_card_registry/services/hub_stats.py

@@ -199,9 +199,22 @@ class HubStatsClient:
             return self._con
         # Import lazily so processes that never call lookup() don't pay
         # the duckdb import cost.
+        import os
         import duckdb
         con = duckdb.connect()
         con.execute("INSTALL httpfs; LOAD httpfs;")
+        # Authenticate parquet fetches when HF_TOKEN is in the environment
+        # (typical on the deployed Space). Unauth limit is 500 req/5min;
+        # one DuckDB read_parquet against the remote file streams via
+        # several range requests and a sync that auto-creates many drafts
+        # can brush that ceiling. With auth the ceiling is ~30k/5min.
+        hf_token = os.environ.get("HF_TOKEN")
+        if hf_token:
+            escaped = hf_token.replace("'", "''")
+            con.execute(
+                f"CREATE SECRET hf_auth (TYPE HTTP, BEARER_TOKEN '{escaped}', "
+                f"SCOPE 'https://huggingface.co');"
+            )
         self._con = con
         return con
 

src/eval_card_registry/services/resolution_service.py

@@ -15,6 +15,7 @@ from datetime import datetime, timezone
 from typing import Optional
 
 from eval_entity_resolver import AliasStore, CanonicalStore, Resolver, ResolverConfig, ResolutionResult
+from eval_entity_resolver.display import humanize_model_slug
 
 from eval_card_registry.config import settings
 from eval_card_registry.store.hf_store import RegistryStore
@@ -294,9 +295,17 @@ class ResolutionService:
             candidate_id = f"{candidate_id}-{str(uuid.uuid4())[:8]}"
 
         now = _now()
+        # Models get a humanized display name (`gpt-5-2025-08-07` ->
+        # `GPT-5 (2025-08-07)`); other entity types pass `raw_value`
+        # through — benchmark/metric/harness/org names are usually
+        # already in their preferred display form.
+        if entity_type == "model":
+            display = humanize_model_slug(raw_value) or raw_value
+        else:
+            display = raw_value
         base = {
             "id": candidate_id,
-            "display_name": raw_value,
+            "display_name": display,
             "metadata": "{}",
             "review_status": "draft",
             "created_at": now,

src/eval_card_registry/store/queries.py

@@ -85,9 +85,12 @@ def derive_model_lineage_fields(store: RegistryStore) -> dict[str, int]:
     `root_model_id`, `lineage_origin_org_id`, and inherited `open_weights`
     columns.
 
-    - `root_model_id`: walk parents up through *only* `quantized` edges
-      (identity-preserving chain). NULL when self has no quantized
-      ancestor — i.e., self IS the identity root.
+    - `root_model_id`: walk parents up through edges that preserve API
+      identity — `quantized` (different precision, same model) and
+      `variant axis=version` (dated snapshot of the same release, e.g.
+      `gpt-4o-2024-05-13` -> `gpt-4o`). NULL when self has no such
+      ancestor — i.e., self IS the identity root. Other variant axes
+      (size, mode, modality, domain) keep separate identity at the leaf.
     - `lineage_origin_org_id`: walk through any non-`variant` edge
       (quantized / finetune / merge / adapter) to the deepest ancestor,
       then read its `org_id`. For Meta-originated models = self.org_id;
@@ -117,8 +120,8 @@ def derive_model_lineage_fields(store: RegistryStore) -> dict[str, int]:
         ow = row.get("open_weights")
         open_by_id[cid] = None if _is_na(ow) else bool(ow)
 
-    def _walk(start: str, allowed: set[str]) -> str:
-        """Walk parents through edges whose relationship is in `allowed`.
+    def _walk(start: str, edge_ok) -> str:
+        """Walk parents through edges where `edge_ok(edge)` is True.
         Returns the deepest reachable id; stops on no-match or cycle."""
         visited = {start}
         current = start
@@ -128,7 +131,7 @@ def derive_model_lineage_fields(store: RegistryStore) -> dict[str, int]:
             for p in edges:
                 if not isinstance(p, dict):
                     continue
-                if p.get("relationship") in allowed and p.get("id"):
+                if edge_ok(p) and p.get("id"):
                     next_id = p["id"]
                     break
             if not next_id or next_id in visited or next_id not in parents_by_id:
@@ -136,6 +139,17 @@ def derive_model_lineage_fields(store: RegistryStore) -> dict[str, int]:
             visited.add(next_id)
             current = next_id
 
+    def _is_identity_edge(p: dict) -> bool:
+        rel = p.get("relationship")
+        if rel == "quantized":
+            return True
+        if rel == "variant" and p.get("axis") == "version":
+            return True
+        return False
+
+    def _is_lineage_edge(p: dict) -> bool:
+        return p.get("relationship") in {"quantized", "finetune", "merge", "adapter"}
+
     def _inherit_open_from_ancestors(start: str) -> Optional[bool]:
         """Walk ONLY ancestors (skip self) through `variant` + `quantized`
         edges and return the first explicit `open_weights` value found.
@@ -166,11 +180,12 @@ def derive_model_lineage_fields(store: RegistryStore) -> dict[str, int]:
     open_updates: dict[str, Optional[bool]] = {}
     inherited_count = 0
     for cid in parents_by_id:
-        # Identity root via quantized-only walk
-        root = _walk(cid, {"quantized"})
+        # Identity root via quantized + variant-version walk (both treat
+        # the parent as the same model at the API level — see docstring).
+        root = _walk(cid, _is_identity_edge)
         root_updates[cid] = root if root != cid else None
         # Lineage origin via any non-variant edge; org of deepest ancestor
-        ancestor = _walk(cid, {"quantized", "finetune", "merge", "adapter"})
+        ancestor = _walk(cid, _is_lineage_edge)
         lineage_updates[cid] = org_by_id.get(ancestor) or org_by_id.get(cid)
         # Open weights — explicit self value WINS; only fall back to
         # ancestor inheritance when self has no value set. Never overwrite