Deploy Space: update src

src/utils.py

@@ -175,6 +175,21 @@ def format_number(value):
     return f"{number:.2f}"
 
 
+def format_rank_number(value):
+    """Format rank-like columns as positive integers for leaderboard display."""
+    if pd.isna(value):
+        return "n/a"
+    number = float(value)
+    if not np.isfinite(number):
+        return "n/a"
+    return str(max(1, int(round(number))))
+
+
+def _is_rank_display_column(column: object) -> bool:
+    name = str(column)
+    return "Rank" in name and name != RANK_SCORE_COLUMN
+
+
 def aggregate_gmean(series: pd.Series) -> float:
     values = pd.to_numeric(series, errors="coerce").dropna()
     values = values[np.isfinite(values) & (values >= 0.0)]
@@ -192,7 +207,8 @@ def format_df(df: pd.DataFrame) -> pd.DataFrame:
     formatted = df.copy()
     for col in formatted.columns:
         if pd.api.types.is_numeric_dtype(formatted[col]):
-            formatted[col] = formatted[col].map(format_number)
+            formatter = format_rank_number if _is_rank_display_column(col) else format_number
+            formatted[col] = formatted[col].map(formatter)
     return formatted
 
 
@@ -419,8 +435,9 @@ def load_gift_aggregate_table(
     table["Coverage"] = table["coverage"].map(
         lambda value: "n/a" if pd.isna(value) else f"{100.0 * float(value):.2f}%"
     )
-    for metric in ("MSE", "CRPS", "Rank"):
+    for metric in ("MSE", "CRPS"):
         table[metric] = pd.to_numeric(table[metric], errors="coerce").map(format_number)
+    table["Rank"] = pd.to_numeric(table["Rank"], errors="coerce").map(format_rank_number)
     table = table.rename(columns={dimension: label, "model": "Model"})
     return table.loc[:, columns].reset_index(drop=True)
 
@@ -508,6 +525,7 @@ def load_live_aggregate_table(
         )
         for metric in ("MSE", "RMSE", "MAPE", "CRPS", "RTG", "Stability", "Improvement"):
             frame[metric] = pd.to_numeric(frame[metric], errors="coerce").map(format_number)
+        frame["Rank"] = pd.to_numeric(frame["Rank"], errors="coerce").map(format_rank_number)
     else:
         source_columns = [
             "Rank",
@@ -531,7 +549,12 @@ def load_live_aggregate_table(
                 "pairwise_matches": "Pairwise Matches",
             }
         )
-        for metric in ("Average Rank", "Win Rate", "Elo"):
+        frame["Rank"] = pd.to_numeric(frame["Rank"], errors="coerce").map(format_rank_number)
+        frame["Average Rank"] = pd.to_numeric(
+            frame["Average Rank"],
+            errors="coerce",
+        ).map(format_rank_number)
+        for metric in ("Win Rate", "Elo"):
             frame[metric] = pd.to_numeric(frame[metric], errors="coerce").map(format_number)
     return frame.loc[:, columns].reset_index(drop=True)
 
@@ -549,8 +572,8 @@ def load_live_aggregate_metadata_md(root_dir: str = "results") -> str:
         f"**Up to now:** {metadata.get('num_models', 0)} models, "
         f"{metadata.get('num_datasets', 0)} datasets, and "
         f"{metadata.get('num_unique_releases', 0)} distinct future releases. "
-        "MSE/RMSE/CRPS use causal context z-normalization; RTG is relative to "
-        "24-step Seasonal-Naive. **Generated:** "
+        "Metrics are stored without forecasts or ground truth; RTG is relative to "
+        "matched Seasonal-Naive MSE. **Generated:** "
         f"{generated}."
     )
 
@@ -772,7 +795,7 @@ def _read_rank_history(path: Path, date_col: str) -> pd.DataFrame:
         return pd.DataFrame(columns=[date_col] + _RANK_COLS)
     for col in _RANK_COLS:
         if col in df.columns:
-            df[col] = pd.to_numeric(df[col], errors="coerce").map(format_number)
+            df[col] = pd.to_numeric(df[col], errors="coerce").map(format_rank_number)
     if date_col in df.columns:
         df = df.sort_values(date_col)
     present = [c for c in [date_col] + _RANK_COLS if c in df.columns]
@@ -1002,26 +1025,44 @@ def _today_start_utc8() -> datetime:
 
 def get_dataset_last_eval_time(ds_base: str, root_dir: str = "results") -> datetime | None:
     latest_dt: datetime | None = None
-    # Scan model directories
+
+    history_path = Path(root_dir) / "eval_history.jsonl"
+    if history_path.exists():
+        try:
+            with history_path.open(encoding="utf-8") as handle:
+                for line in handle:
+                    if not line.strip():
+                        continue
+                    entry = json.loads(line)
+                    if _dataset_key(entry.get("dataset", "")) != _dataset_key(ds_base):
+                        continue
+                    dt = _parse_timestamp(entry.get("evaluated_at"))
+                    if dt is not None and (latest_dt is None or dt > latest_dt):
+                        latest_dt = dt
+        except Exception:
+            pass
+
     for model_dir in Path(root_dir).iterdir():
         if not model_dir.is_dir():
             continue
-        forecasts_dir = model_dir / "forecasts"
-        if not forecasts_dir.is_dir():
+        meta_path = model_dir / "online_meta.json"
+        if not meta_path.exists():
             continue
-        # Find files matching the base name
-        for fp in forecasts_dir.glob(f"{ds_base}*.json"):
-            try:
-                # To be super fast, regex search for evaluated_at
-                content = fp.read_text()
-                match = re.search(r'"evaluated_at"\s*:\s*"([^"]+)"', content)
-                if match:
-                    eval_at = match.group(1)
-                    dt = datetime.fromisoformat(eval_at.replace("Z", "+00:00"))
-                    if latest_dt is None or dt > latest_dt:
-                        latest_dt = dt
-            except Exception:
-                continue
+        try:
+            meta = json.loads(meta_path.read_text())
+        except Exception:
+            continue
+        matched = False
+        for item in meta.get("datasets", []):
+            raw_name = str(item.get("dataset", ""))
+            if _dataset_key(raw_name) == _dataset_key(ds_base) or ds_base.lower() in raw_name.lower():
+                matched = True
+                break
+        if not matched:
+            continue
+        dt = _parse_timestamp(meta.get("evaluated_at"))
+        if dt is not None and (latest_dt is None or dt > latest_dt):
+            latest_dt = dt
     return latest_dt
 
 
@@ -1076,30 +1117,11 @@ def make_domain_pie_chart(root_dir: str = "results") -> object | None:
         except Exception:
             pass
 
-    # Fallback to cumulative snapshots count (no today filter) if empty
+    # Fallback to one count per current dataset if history is unavailable.
     if not timestamp_counts:
-        seen_datasets: set[str] = set()
-        for model_dir in sorted(Path(root_dir).iterdir()):
-            if not model_dir.is_dir():
-                continue
-            forecasts_dir = model_dir / "forecasts"
-            if not forecasts_dir.is_dir():
-                continue
-            for fp in forecasts_dir.glob("*.json"):
-                try:
-                    snap = json.loads(fp.read_text())
-                except Exception:
-                    continue
-                ds_full = snap.get("dataset", "")
-                ds_base = ds_full.split("/")[0]
-                if ds_base in seen_datasets:
-                    continue
-                seen_datasets.add(ds_base)
-
-                domain = get_domain(ds_base)
-                n_ts = len(snap.get("context", [])) + len(snap.get("actuals", []))
-                timestamp_counts[domain] = timestamp_counts.get(domain, 0) + n_ts
-                domain_datasets.setdefault(domain, set()).add(dataset_short_name(ds_base))
+        for ds_base, domain in domain_map.items():
+            timestamp_counts[domain] = timestamp_counts.get(domain, 0) + 1
+            domain_datasets.setdefault(domain, set()).add(dataset_short_name(ds_base))
 
     if not timestamp_counts:
         return None