Initial deploy v2

.streamlit/config.toml

@@ -0,0 +1,8 @@
+[server]
+headless = true
+port = 7860
+enableCORS = false
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false

Dockerfile

@@ -0,0 +1,32 @@
+FROM python:3.11-slim
+
+ENV PYTHONUNBUFFERED=1 \
+    PIP_NO_CACHE_DIR=1
+
+# Dev Mode requirements for Docker Spaces:
+# bash, curl, wget, procps, git, git-lfs.
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    bash \
+    curl \
+    wget \
+    procps \
+    git \
+    git-lfs \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+RUN useradd --create-home --uid 1000 appuser
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+RUN pip install --upgrade pip && pip install -r /app/requirements.txt
+
+COPY . /app
+RUN chown -R 1000:1000 /app
+
+USER 1000
+
+EXPOSE 7860
+
+CMD ["streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0", "--server.headless=true", "--server.enableCORS=false", "--server.enableXsrfProtection=false", "--browser.gatherUsageStats=false"]

README.md

@@ -1,10 +1,85 @@
 ---
-title: Segmentation Eval Dashboard V2
-emoji: 👀
+title: Segmentation Eval Dashboard
+emoji: 📊
 colorFrom: blue
 colorTo: green
 sdk: docker
+app_port: 7860
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Segmentation Evaluation Metrics Dashboard
+
+Streamlit dashboard for tracking segmentation evaluation metrics stored in Hugging Face **dataset cards** under a Markdown section titled exactly:
+
+`### Performance Metrics`
+
+The app discovers dataset repos (typically with `eval` in the repo id), parses the metrics table, and builds a historical view from commit revisions when possible.
+
+## Features
+
+- Dataset discovery from Hugging Face Hub (`huggingface_hub` API)
+- Allowlist/prefix-based repo filtering via environment variables
+- Robust Markdown section/table parsing for `Performance Metrics`
+- Historical trend extraction using dataset commit history
+- Filters by repo, class, and metric
+- Trend chart with optional standard-deviation bands
+- Latest snapshot table
+- Repo-to-repo comparison chart on latest runs
+- Optional per-class small multiples
+- CSV export for filtered data
+- Health/status panel (parsed vs failed repos)
+- Auto-refresh and cached Hub calls
+
+## Project Structure
+
+- `app.py`: Streamlit entrypoint and UI
+- `config.py`: env-based configuration
+- `hf_client.py`: Hugging Face Hub API access and README retrieval
+- `parsing.py`: Markdown section/table extraction
+- `transforms.py`: data normalization, history shaping, latest snapshots
+- `charts.py`: Altair chart builders
+- `requirements.txt`: Python dependencies
+
+## Required Environment Variables
+
+- `HF_TOKEN` (optional, recommended for private repos or higher rate limits)
+- `HF_OWNER` (optional namespace/organization filter, e.g. `my-org`)
+
+## Optional Environment Variables
+
+- `EVAL_REPO_ALLOWLIST` (comma-separated dataset ids)
+- `EVAL_REPO_PREFIXES` (comma-separated prefixes, e.g. `my-org/`)
+- `EVAL_REPO_ID_CONTAINS` (default: `eval`)
+- `EVAL_DISCOVERY_ENABLED` (`true`/`false`, default: `true`)
+- `EVAL_MAX_REPOS` (default: `200`)
+- `EVAL_INCLUDE_HISTORY` (`true`/`false`, default: `true`)
+- `EVAL_MAX_COMMITS_PER_REPO` (default: `20`)
+- `EVAL_METRICS_SECTION_HEADING` (default: `Performance Metrics`)
+- `EVAL_CACHE_TTL_SECONDS` (default: `600`)
+- `EVAL_AUTO_REFRESH_SECONDS` (default: `300`)
+- `EVAL_MAX_LOAD_SECONDS` (default: `90`)
+
+## Local Run
+
+```bash
+pip install -r requirements.txt
+streamlit run app.py
+```
+
+## Deploy to Hugging Face Space
+
+1. Create a new **Space** with SDK = **Streamlit**.
+2. Copy all files in this folder to the Space repository root.
+3. In Space settings, set secrets/variables as needed:
+   - `HF_TOKEN` (as a secret)
+   - any optional `EVAL_*` vars for discovery behavior
+4. Push to the Space.
+5. The app will start from `app.py`.
+
+## Notes / Limitations
+
+- History quality depends on README/table availability across commits.
+- If commit history is unavailable or inaccessible, the app still supports latest snapshot parsing.
+- Table parsing is tolerant to minor Markdown inconsistencies, but severely malformed tables are skipped.
+- Missing numeric values (`nan`, `NA`, empty) are treated as `NaN` and handled safely in charts/tables.

app.py

@@ -0,0 +1,309 @@
+from __future__ import annotations
+
+import logging
+import os
+import time
+from typing import Any
+
+import pandas as pd
+import streamlit as st
+
+from charts import (
+    build_class_small_multiples,
+    build_latest_comparison_chart,
+    build_trend_chart,
+)
+from config import AppConfig, load_config
+from hf_client import HubClient, RepoRevision
+from parsing import extract_performance_metrics_table
+from transforms import (
+    add_latest_flags,
+    build_latest_snapshot_table,
+    filter_history,
+    normalize_metrics_dataframe,
+    table_to_long_dataframe,
+)
+
+try:
+    from streamlit_autorefresh import st_autorefresh
+except Exception:  # pragma: no cover
+    def st_autorefresh(*args: Any, **kwargs: Any) -> None:
+        return None
+
+
+CACHE_TTL_SECONDS = int(os.getenv("EVAL_CACHE_TTL_SECONDS", "600"))
+LOG_LEVEL = os.getenv("EVAL_LOG_LEVEL", "INFO").upper()
+logging.basicConfig(level=getattr(logging, LOG_LEVEL, logging.INFO))
+logger = logging.getLogger("segmentation_eval_dashboard")
+
+
+st.set_page_config(
+    page_title="Segmentation Evaluation Dashboard",
+    layout="wide",
+)
+
+
+@st.cache_data(ttl=CACHE_TTL_SECONDS, show_spinner="Loading metrics from Hugging Face Hub...")
+def collect_dashboard_data(config: AppConfig) -> tuple[pd.DataFrame, pd.DataFrame, list[str]]:
+    client = HubClient(config)
+    repos = client.discover_dataset_repos()
+    logger.info("Discovered %d candidate repos", len(repos))
+    start_time = time.monotonic()
+
+    history_frames: list[pd.DataFrame] = []
+    status_rows: list[dict[str, Any]] = []
+
+    for repo_id in repos:
+        elapsed = time.monotonic() - start_time
+        if elapsed >= config.max_load_seconds:
+            status_rows.append(
+                {
+                    "repo_id": "__load_guard__",
+                    "status": "partial",
+                    "revisions_checked": 0,
+                    "revisions_parsed": 0,
+                    "points": 0,
+                    "latest_timestamp": pd.NaT,
+                    "message": f"Stopped early after {config.max_load_seconds}s to keep app responsive",
+                }
+            )
+            logger.warning("Load guard triggered after %.1fs", elapsed)
+            break
+
+        revisions_checked = 0
+        revisions_parsed = 0
+        points = 0
+        message = ""
+        commit_error_message = ""
+
+        try:
+            commit_limit = config.max_commits_per_repo if config.include_history else 1
+            revisions = client.list_dataset_commits(repo_id=repo_id, max_commits=max(1, commit_limit))
+        except Exception as exc:  # pragma: no cover
+            revisions = [RepoRevision(repo_id=repo_id, revision="main", committed_at=None)]
+            commit_error_message = f"Commit listing failed ({type(exc).__name__}); fallback to main"
+            logger.warning("Repo %s: %s", repo_id, commit_error_message)
+
+        repo_frames: list[pd.DataFrame] = []
+        seen_revisions: set[str] = set()
+        for revision_info in revisions:
+            revision = revision_info.revision
+            if revision in seen_revisions:
+                continue
+
+            revisions_checked += 1
+            seen_revisions.add(revision)
+
+            readme = client.fetch_dataset_readme(repo_id=repo_id, revision=revision)
+            if not readme:
+                continue
+
+            metrics_table = extract_performance_metrics_table(
+                markdown=readme,
+                heading=config.metrics_section_heading,
+            )
+            if metrics_table is None or metrics_table.empty:
+                continue
+
+            normalized = normalize_metrics_dataframe(metrics_table)
+            if normalized.empty:
+                continue
+
+            long_df = table_to_long_dataframe(
+                dataframe=normalized,
+                repo_id=repo_id,
+                revision=revision,
+                committed_at=revision_info.committed_at,
+                metrics=config.metrics,
+            )
+            if long_df.empty:
+                continue
+
+            revisions_parsed += 1
+            points += len(long_df)
+            repo_frames.append(long_df)
+
+        if repo_frames:
+            repo_history = pd.concat(repo_frames, ignore_index=True)
+            history_frames.append(repo_history)
+            latest_timestamp = repo_history["timestamp"].max()
+            status = "ok"
+            message = f"Parsed {revisions_parsed}/{revisions_checked} revisions"
+            if commit_error_message:
+                message = f"{message}. {commit_error_message}"
+        else:
+            latest_timestamp = pd.NaT
+            status = "error" if commit_error_message else "no_metrics"
+            message = commit_error_message or "No valid Performance Metrics table found"
+
+        status_rows.append(
+            {
+                "repo_id": repo_id,
+                "status": status,
+                "revisions_checked": revisions_checked,
+                "revisions_parsed": revisions_parsed,
+                "points": points,
+                "latest_timestamp": latest_timestamp,
+                "message": message,
+            }
+        )
+        logger.info(
+            "Repo %s: status=%s revisions_checked=%d revisions_parsed=%d points=%d",
+            repo_id,
+            status,
+            revisions_checked,
+            revisions_parsed,
+            points,
+        )
+
+    if history_frames:
+        history_df = pd.concat(history_frames, ignore_index=True)
+        history_df = history_df.sort_values(["timestamp", "repo_id", "revision", "class", "metric"])  # type: ignore[arg-type]
+        history_df = add_latest_flags(history_df)
+    else:
+        history_df = pd.DataFrame(
+            columns=["repo_id", "revision", "timestamp", "class", "metric", "value", "std", "is_latest"]
+        )
+
+    status_df = pd.DataFrame(status_rows)
+    if not status_df.empty and "latest_timestamp" in status_df.columns:
+        status_df["latest_timestamp"] = pd.to_datetime(status_df["latest_timestamp"], utc=True, errors="coerce")
+
+    return history_df, status_df, repos
+
+
+def main() -> None:
+    config = load_config()
+
+    if config.auto_refresh_seconds > 0:
+        st_autorefresh(interval=config.auto_refresh_seconds * 1000, key="dashboard-refresh")
+
+    st.title("Segmentation Evaluation Metrics Dashboard")
+    st.caption("Source: Hugging Face dataset cards (`### Performance Metrics`).")
+
+    with st.sidebar:
+        st.header("Controls")
+        if st.button("Refresh now", use_container_width=True):
+            st.cache_data.clear()
+            st.rerun()
+
+        st.caption(
+            "Filtering/discovery is configured by env vars: "
+            "`HF_OWNER`, `EVAL_REPO_ALLOWLIST`, `EVAL_REPO_PREFIXES`, `EVAL_REPO_ID_CONTAINS`."
+        )
+        show_error_bands = st.checkbox("Show std error bands", value=True)
+        show_small_multiples = st.checkbox("Show class small multiples", value=False)
+
+    history_df, status_df, discovered_repos = collect_dashboard_data(config)
+    logger.info(
+        "UI load complete: discovered=%d parsed_rows=%d status_rows=%d",
+        len(discovered_repos),
+        len(history_df),
+        len(status_df),
+    )
+
+    if not discovered_repos:
+        st.warning("No dataset repositories were discovered. Check owner/prefix/allowlist environment variables.")
+        st.stop()
+
+    available_repos = sorted(history_df["repo_id"].dropna().unique().tolist()) if not history_df.empty else discovered_repos
+    available_classes = sorted(history_df["class"].dropna().unique().tolist()) if not history_df.empty else []
+    available_metrics = sorted(history_df["metric"].dropna().unique().tolist()) if not history_df.empty else list(config.metrics)
+
+    with st.sidebar:
+        selected_repos = st.multiselect("Repos", options=available_repos, default=available_repos)
+        selected_classes = st.multiselect("Classes", options=available_classes, default=available_classes)
+        default_metrics = [metric for metric in config.metrics if metric in available_metrics] or available_metrics
+        selected_metrics = st.multiselect("Metrics", options=available_metrics, default=default_metrics)
+
+    filtered_history = filter_history(
+        history_df=history_df,
+        repos=selected_repos,
+        classes=selected_classes,
+        metrics=selected_metrics,
+    )
+
+    latest_filtered = filtered_history[filtered_history["is_latest"]].copy()
+
+    success_repos = int((status_df["status"] == "ok").sum()) if not status_df.empty else 0
+    latest_runs = latest_filtered[["repo_id", "revision"]].drop_duplicates().shape[0] if not latest_filtered.empty else 0
+    latest_f1 = latest_filtered[latest_filtered["metric"] == "F1"]["value"].mean() if not latest_filtered.empty else float("nan")
+    latest_timestamp = filtered_history["timestamp"].max() if not filtered_history.empty else pd.NaT
+
+    col1, col2, col3, col4 = st.columns(4)
+    col1.metric("Discovered repos", len(discovered_repos))
+    col2.metric("Repos parsed", success_repos)
+    col3.metric("Latest runs in view", latest_runs)
+    col4.metric("Latest mean F1", f"{latest_f1:.3f}" if pd.notna(latest_f1) else "n/a")
+
+    if pd.notna(latest_timestamp):
+        st.caption(f"Most recent datapoint: {pd.to_datetime(latest_timestamp).strftime('%Y-%m-%d %H:%M:%S %Z')}")
+
+    st.subheader("Trend Over Time")
+    trend_chart = build_trend_chart(filtered_history, show_error_bands=show_error_bands)
+    if trend_chart is None:
+        st.info("No trend data available for the active filters.")
+    else:
+        st.altair_chart(trend_chart, use_container_width=True)
+
+    st.subheader("Latest Snapshot")
+    snapshot_table = build_latest_snapshot_table(filtered_history)
+    if snapshot_table.empty:
+        st.info("No latest snapshot rows for current filters.")
+    else:
+        st.dataframe(snapshot_table, use_container_width=True, hide_index=True)
+
+    st.subheader("Repo Comparison (Latest)")
+    comparison_metric_options = selected_metrics or available_metrics
+    comparison_metric = None
+    if comparison_metric_options:
+        comparison_metric = st.selectbox(
+            "Metric for repo comparison",
+            options=comparison_metric_options,
+            index=0,
+        )
+
+    if comparison_metric is not None:
+        comparison_chart = build_latest_comparison_chart(filtered_history, metric=comparison_metric)
+        if comparison_chart is None:
+            st.info("No latest comparison data available for this metric.")
+        else:
+            st.altair_chart(comparison_chart, use_container_width=True)
+
+    if show_small_multiples and comparison_metric:
+        st.subheader("Per-Class Small Multiples")
+        small_multiples_chart = build_class_small_multiples(filtered_history, metric=comparison_metric)
+        if small_multiples_chart is None:
+            st.info("No small-multiple data available for this metric.")
+        else:
+            st.altair_chart(small_multiples_chart, use_container_width=True)
+
+    st.subheader("Export")
+    csv_bytes = filtered_history.to_csv(index=False).encode("utf-8")
+    st.download_button(
+        "Export filtered history as CSV",
+        data=csv_bytes,
+        file_name="segmentation_metrics_history.csv",
+        mime="text/csv",
+        use_container_width=False,
+    )
+
+    with st.expander("Health / Status", expanded=False):
+        if status_df.empty:
+            st.info("No status rows to display.")
+        else:
+            st.dataframe(status_df.sort_values(["status", "repo_id"]), use_container_width=True, hide_index=True)
+
+    with st.expander("Raw Parsed Data", expanded=False):
+        if filtered_history.empty:
+            st.info("No parsed rows for current filters.")
+        else:
+            st.dataframe(
+                filtered_history.sort_values(["timestamp", "repo_id", "class", "metric"], ascending=[False, True, True, True]),
+                use_container_width=True,
+                hide_index=True,
+            )
+
+
+if __name__ == "__main__":
+    main()

charts.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+
+import altair as alt
+import pandas as pd
+
+
+def build_trend_chart(dataframe: pd.DataFrame, show_error_bands: bool = False) -> alt.Chart | None:
+    if dataframe.empty:
+        return None
+
+    chart_data = dataframe.copy()
+    chart_data = chart_data.dropna(subset=["timestamp", "value"])
+    if chart_data.empty:
+        return None
+
+    chart_data["repo_class"] = chart_data["repo_id"] + " | " + chart_data["class"]
+
+    base = alt.Chart(chart_data).encode(
+        x=alt.X("timestamp:T", title="Time"),
+        y=alt.Y("value:Q", title="Metric value"),
+        color=alt.Color("repo_id:N", title="Repo"),
+        strokeDash=alt.StrokeDash("class:N", title="Class"),
+        tooltip=[
+            alt.Tooltip("timestamp:T", title="Timestamp"),
+            alt.Tooltip("repo_id:N", title="Repo"),
+            alt.Tooltip("revision:N", title="Revision"),
+            alt.Tooltip("class:N", title="Class"),
+            alt.Tooltip("metric:N", title="Metric"),
+            alt.Tooltip("value:Q", title="Value", format=".4f"),
+            alt.Tooltip("std:Q", title="Std", format=".4f"),
+        ],
+    )
+
+    line = base.mark_line(point=True)
+
+    chart: alt.Chart | alt.LayerChart = line
+    band_data = chart_data.dropna(subset=["std"]).copy()
+    if show_error_bands and not band_data.empty:
+        band_data["lower"] = band_data["value"] - band_data["std"]
+        band_data["upper"] = band_data["value"] + band_data["std"]
+
+        band = alt.Chart(band_data).mark_area(opacity=0.15).encode(
+            x=alt.X("timestamp:T", title="Time"),
+            y=alt.Y("lower:Q", title="Metric value"),
+            y2="upper:Q",
+            color=alt.Color("repo_id:N", title="Repo"),
+            detail="repo_class:N",
+        )
+        chart = band + line
+
+    metric_count = chart_data["metric"].nunique()
+    if metric_count > 1:
+        return chart.facet(row=alt.Row("metric:N", title=None)).resolve_scale(y="independent")
+
+    return chart
+
+
+def build_latest_comparison_chart(dataframe: pd.DataFrame, metric: str) -> alt.Chart | None:
+    if dataframe.empty:
+        return None
+
+    latest = dataframe[dataframe["is_latest"] & (dataframe["metric"] == metric)].dropna(subset=["value"])
+    if latest.empty:
+        return None
+
+    return (
+        alt.Chart(latest)
+        .mark_bar()
+        .encode(
+            x=alt.X("repo_id:N", title="Repo", sort="-y"),
+            y=alt.Y("value:Q", title=f"Latest {metric}"),
+            color=alt.Color("class:N", title="Class"),
+            tooltip=[
+                alt.Tooltip("repo_id:N", title="Repo"),
+                alt.Tooltip("revision:N", title="Revision"),
+                alt.Tooltip("class:N", title="Class"),
+                alt.Tooltip("value:Q", title="Value", format=".4f"),
+                alt.Tooltip("std:Q", title="Std", format=".4f"),
+            ],
+        )
+    )
+
+
+def build_class_small_multiples(dataframe: pd.DataFrame, metric: str) -> alt.Chart | None:
+    if dataframe.empty:
+        return None
+
+    plot_df = dataframe[dataframe["metric"] == metric].dropna(subset=["value"])
+    if plot_df.empty:
+        return None
+
+    chart = (
+        alt.Chart(plot_df)
+        .mark_line(point=True)
+        .encode(
+            x=alt.X("timestamp:T", title="Time"),
+            y=alt.Y("value:Q", title=metric),
+            color=alt.Color("repo_id:N", title="Repo"),
+            tooltip=[
+                alt.Tooltip("timestamp:T", title="Timestamp"),
+                alt.Tooltip("repo_id:N", title="Repo"),
+                alt.Tooltip("revision:N", title="Revision"),
+                alt.Tooltip("class:N", title="Class"),
+                alt.Tooltip("value:Q", title="Value", format=".4f"),
+            ],
+        )
+    )
+
+    return chart.facet(column=alt.Column("class:N", title=None, sort="ascending"))

config.py

@@ -0,0 +1,69 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import os
+from typing import Tuple
+
+DEFAULT_METRICS: Tuple[str, ...] = (
+    "F1",
+    "Precision",
+    "Recall",
+    "Mean_IoU",
+    "Mean_TP_IoU",
+)
+
+
+def _parse_bool(value: str | None, default: bool) -> bool:
+    if value is None:
+        return default
+    normalized = value.strip().lower()
+    if normalized in {"1", "true", "yes", "y", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "n", "off"}:
+        return False
+    return default
+
+
+def _parse_csv(value: str | None) -> tuple[str, ...]:
+    if not value:
+        return tuple()
+    items = [item.strip() for item in value.split(",")]
+    return tuple(item for item in items if item)
+
+
+@dataclass(frozen=True)
+class AppConfig:
+    hf_token: str | None
+    hf_owner: str | None
+    repo_allowlist: tuple[str, ...]
+    repo_prefixes: tuple[str, ...]
+    repo_id_contains: str
+    discovery_enabled: bool
+    max_repos: int
+    include_history: bool
+    max_commits_per_repo: int
+    metrics_section_heading: str
+    cache_ttl_seconds: int
+    auto_refresh_seconds: int
+    max_load_seconds: int
+    metrics: tuple[str, ...]
+
+
+
+def load_config() -> AppConfig:
+    return AppConfig(
+        hf_token=os.getenv("HF_TOKEN") or None,
+        hf_owner=os.getenv("HF_OWNER") or None,
+        repo_allowlist=_parse_csv(os.getenv("EVAL_REPO_ALLOWLIST")),
+        repo_prefixes=_parse_csv(os.getenv("EVAL_REPO_PREFIXES")),
+        repo_id_contains=os.getenv("EVAL_REPO_ID_CONTAINS", "eval").strip(),
+        discovery_enabled=_parse_bool(os.getenv("EVAL_DISCOVERY_ENABLED"), True),
+        max_repos=int(os.getenv("EVAL_MAX_REPOS", "200")),
+        include_history=_parse_bool(os.getenv("EVAL_INCLUDE_HISTORY"), True),
+        max_commits_per_repo=int(os.getenv("EVAL_MAX_COMMITS_PER_REPO", "20")),
+        metrics_section_heading=os.getenv("EVAL_METRICS_SECTION_HEADING", "Performance Metrics").strip(),
+        cache_ttl_seconds=int(os.getenv("EVAL_CACHE_TTL_SECONDS", "600")),
+        auto_refresh_seconds=int(os.getenv("EVAL_AUTO_REFRESH_SECONDS", "300")),
+        max_load_seconds=int(os.getenv("EVAL_MAX_LOAD_SECONDS", "90")),
+        metrics=DEFAULT_METRICS,
+    )

hf_client.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+from huggingface_hub import HfApi, hf_hub_download
+from huggingface_hub.utils import EntryNotFoundError, HfHubHTTPError
+
+from config import AppConfig
+
+
+README_CANDIDATES = ("README.md", "readme.md")
+
+
+@dataclass(frozen=True)
+class RepoRevision:
+    repo_id: str
+    revision: str
+    committed_at: datetime | None
+
+
+class HubClient:
+    def __init__(self, config: AppConfig):
+        self.config = config
+        self.api = HfApi(token=config.hf_token)
+
+    def discover_dataset_repos(self) -> list[str]:
+        repos = set(self.config.repo_allowlist)
+
+        if self.config.discovery_enabled:
+            try:
+                datasets = self.api.list_datasets(
+                    author=self.config.hf_owner,
+                    search=self.config.repo_id_contains or None,
+                    limit=max(self.config.max_repos * 3, self.config.max_repos),
+                    full=False,
+                )
+                for dataset in datasets:
+                    repo_id = getattr(dataset, "id", None)
+                    if not repo_id:
+                        continue
+                    if self._repo_matches_filters(repo_id):
+                        repos.add(repo_id)
+                    if len(repos) >= self.config.max_repos:
+                        break
+            except HfHubHTTPError:
+                pass
+
+        filtered = [repo for repo in repos if self._repo_matches_filters(repo)]
+        return sorted(filtered)[: self.config.max_repos]
+
+    def list_dataset_commits(self, repo_id: str, max_commits: int) -> list[RepoRevision]:
+        revisions: list[RepoRevision] = []
+        try:
+            commits = self.api.list_repo_commits(repo_id=repo_id, repo_type="dataset")
+            for commit in commits[:max_commits]:
+                revision = getattr(commit, "commit_id", None) or getattr(commit, "oid", None)
+                if not revision:
+                    continue
+                committed_at = _coerce_datetime(getattr(commit, "created_at", None) or getattr(commit, "date", None))
+                revisions.append(
+                    RepoRevision(
+                        repo_id=repo_id,
+                        revision=revision,
+                        committed_at=committed_at,
+                    )
+                )
+        except HfHubHTTPError:
+            revisions = []
+
+        if revisions:
+            return revisions
+
+        try:
+            info = self.api.dataset_info(repo_id=repo_id)
+            fallback_revision = getattr(info, "sha", None) or "main"
+            fallback_timestamp = _coerce_datetime(getattr(info, "lastModified", None))
+        except HfHubHTTPError:
+            fallback_revision = "main"
+            fallback_timestamp = None
+
+        return [RepoRevision(repo_id=repo_id, revision=fallback_revision, committed_at=fallback_timestamp)]
+
+    def fetch_dataset_readme(self, repo_id: str, revision: str | None = None) -> str | None:
+        for filename in README_CANDIDATES:
+            try:
+                path = hf_hub_download(
+                    repo_id=repo_id,
+                    filename=filename,
+                    repo_type="dataset",
+                    revision=revision,
+                    token=self.config.hf_token,
+                )
+                return Path(path).read_text(encoding="utf-8", errors="replace")
+            except EntryNotFoundError:
+                continue
+            except HfHubHTTPError:
+                continue
+        return None
+
+    def _repo_matches_filters(self, repo_id: str) -> bool:
+        lowered_repo_id = repo_id.lower()
+
+        if self.config.repo_id_contains and self.config.repo_id_contains.lower() not in lowered_repo_id:
+            return False
+
+        if self.config.repo_prefixes and not any(repo_id.startswith(prefix) for prefix in self.config.repo_prefixes):
+            return False
+
+        return True
+
+
+def _coerce_datetime(value: Any) -> datetime | None:
+    if value is None:
+        return None
+
+    timestamp = pd.to_datetime(value, errors="coerce", utc=True)
+    if pd.isna(timestamp):
+        return None
+    return timestamp.to_pydatetime()

parsing.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+
+import re
+from typing import Iterable
+
+import pandas as pd
+
+
+HEADING_RE = re.compile(r"^\s{0,3}(#{1,6})\s+(.*?)\s*$")
+TABLE_DIVIDER_CELL_RE = re.compile(r"^:?-{3,}:?$")
+
+
+def extract_markdown_section(markdown: str, heading: str) -> str | None:
+    lines = markdown.splitlines()
+    heading_normalized = heading.strip().lower()
+
+    start_index: int | None = None
+    heading_level: int | None = None
+
+    for index, line in enumerate(lines):
+        match = HEADING_RE.match(line)
+        if not match:
+            continue
+        title = match.group(2).strip().lower()
+        if title == heading_normalized:
+            start_index = index + 1
+            heading_level = len(match.group(1))
+            break
+
+    if start_index is None or heading_level is None:
+        return None
+
+    end_index = len(lines)
+    for index in range(start_index, len(lines)):
+        match = HEADING_RE.match(lines[index])
+        if not match:
+            continue
+        next_heading_level = len(match.group(1))
+        if next_heading_level <= heading_level:
+            end_index = index
+            break
+
+    section = "\n".join(lines[start_index:end_index]).strip()
+    return section or None
+
+
+def extract_performance_metrics_table(markdown: str, heading: str = "Performance Metrics") -> pd.DataFrame | None:
+    section = extract_markdown_section(markdown, heading)
+    if not section:
+        return None
+
+    blocks = _extract_table_blocks(section)
+    for block in blocks:
+        table = _parse_markdown_table_block(block)
+        if table is None or table.empty:
+            continue
+
+        normalized_columns = {str(col).strip().lower() for col in table.columns}
+        if "class" in normalized_columns:
+            return table
+
+    if blocks:
+        fallback = _parse_markdown_table_block(blocks[0])
+        if fallback is not None and not fallback.empty:
+            return fallback
+
+    return None
+
+
+def _extract_table_blocks(text: str) -> list[list[str]]:
+    lines = text.splitlines()
+    blocks: list[list[str]] = []
+    current_block: list[str] = []
+
+    for line in lines:
+        if "|" in line:
+            current_block.append(line)
+            continue
+
+        if len(current_block) >= 2:
+            blocks.append(current_block)
+        current_block = []
+
+    if len(current_block) >= 2:
+        blocks.append(current_block)
+
+    return blocks
+
+
+def _parse_markdown_table_block(lines: Iterable[str]) -> pd.DataFrame | None:
+    rows = [_split_markdown_row(line) for line in lines if line.strip()]
+    if len(rows) < 2:
+        return None
+
+    header_index = None
+    for index in range(len(rows) - 1):
+        if _is_divider_row(rows[index + 1]):
+            header_index = index
+            break
+
+    if header_index is None:
+        return None
+
+    header = [cell.strip() for cell in rows[header_index]]
+    if not header or len(header) < 2:
+        return None
+
+    data_rows = rows[header_index + 2 :]
+    normalized_rows: list[list[str]] = []
+
+    for row in data_rows:
+        if _is_divider_row(row):
+            continue
+
+        padded = row[: len(header)] + [""] * max(0, len(header) - len(row))
+        if any(cell.strip() for cell in padded):
+            normalized_rows.append(padded)
+
+    if not normalized_rows:
+        return None
+
+    dataframe = pd.DataFrame(normalized_rows, columns=header)
+    dataframe.columns = [str(column).strip() for column in dataframe.columns]
+    return dataframe
+
+
+def _split_markdown_row(line: str) -> list[str]:
+    raw = line.strip().strip("|")
+    return [cell.strip() for cell in raw.split("|")]
+
+
+def _is_divider_row(row: Iterable[str]) -> bool:
+    cells = [cell.strip() for cell in row]
+    if not cells:
+        return False
+    return all(TABLE_DIVIDER_CELL_RE.match(cell) for cell in cells if cell)

requirements.txt

@@ -0,0 +1,6 @@
+streamlit>=1.36.0
+pandas>=2.2.0
+numpy>=1.26.0
+altair>=5.3.0
+huggingface_hub>=0.24.0
+streamlit-autorefresh>=1.0.1

transforms.py

@@ -0,0 +1,197 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import re
+from typing import Iterable
+
+import numpy as np
+import pandas as pd
+
+
+_CANONICAL_METRIC_MAP = {
+    "precision": "Precision",
+    "recall": "Recall",
+    "f1": "F1",
+    "meaniou": "Mean_IoU",
+    "meantpiou": "Mean_TP_IoU",
+}
+
+
+def normalize_metrics_dataframe(dataframe: pd.DataFrame) -> pd.DataFrame:
+    if dataframe.empty:
+        return pd.DataFrame()
+
+    rename_map: dict[str, str] = {}
+    class_column: str | None = None
+
+    for column in dataframe.columns:
+        normalized = _normalize_key(column)
+        if normalized == "class":
+            class_column = str(column)
+            rename_map[str(column)] = "Class"
+            continue
+
+        if normalized.endswith("std"):
+            metric_key = normalized[: -len("std")]
+            metric_name = _CANONICAL_METRIC_MAP.get(metric_key)
+            if metric_name:
+                rename_map[str(column)] = f"{metric_name}_std"
+            continue
+
+        metric_name = _CANONICAL_METRIC_MAP.get(normalized)
+        if metric_name:
+            rename_map[str(column)] = metric_name
+
+    if class_column is None:
+        return pd.DataFrame()
+
+    cleaned = dataframe.rename(columns=rename_map).copy()
+    cleaned["Class"] = cleaned["Class"].astype(str).str.strip()
+    cleaned = cleaned[cleaned["Class"] != ""]
+
+    for column in cleaned.columns:
+        if column == "Class":
+            continue
+        cleaned[column] = cleaned[column].apply(_parse_float)
+
+    return cleaned.reset_index(drop=True)
+
+
+def table_to_long_dataframe(
+    dataframe: pd.DataFrame,
+    repo_id: str,
+    revision: str,
+    committed_at: datetime | None,
+    metrics: Iterable[str],
+) -> pd.DataFrame:
+    if dataframe.empty:
+        return pd.DataFrame()
+
+    timestamp = pd.to_datetime(committed_at or datetime.now(timezone.utc), utc=True)
+
+    frames: list[pd.DataFrame] = []
+    for metric in metrics:
+        if metric not in dataframe.columns:
+            continue
+
+        metric_frame = pd.DataFrame(
+            {
+                "repo_id": repo_id,
+                "revision": revision,
+                "timestamp": timestamp,
+                "class": dataframe["Class"].astype(str),
+                "metric": metric,
+                "value": dataframe[metric],
+                "std": dataframe.get(f"{metric}_std", np.nan),
+            }
+        )
+        frames.append(metric_frame)
+
+    if not frames:
+        return pd.DataFrame()
+
+    long_df = pd.concat(frames, ignore_index=True)
+    long_df["value"] = pd.to_numeric(long_df["value"], errors="coerce")
+    long_df["std"] = pd.to_numeric(long_df["std"], errors="coerce")
+    long_df["timestamp"] = pd.to_datetime(long_df["timestamp"], utc=True, errors="coerce")
+    long_df = long_df.dropna(subset=["timestamp"])
+    return long_df
+
+
+def add_latest_flags(history_df: pd.DataFrame) -> pd.DataFrame:
+    if history_df.empty:
+        result = history_df.copy()
+        result["is_latest"] = False
+        return result
+
+    unique_runs = history_df[["repo_id", "revision", "timestamp"]].drop_duplicates()
+    latest_runs = (
+        unique_runs.sort_values(["repo_id", "timestamp", "revision"])
+        .groupby("repo_id", as_index=False)
+        .tail(1)
+        .assign(is_latest=True)
+    )
+
+    merged = history_df.merge(
+        latest_runs,
+        on=["repo_id", "revision", "timestamp"],
+        how="left",
+    )
+    merged["is_latest"] = merged["is_latest"].fillna(False)
+    return merged
+
+
+def filter_history(
+    history_df: pd.DataFrame,
+    repos: Iterable[str],
+    classes: Iterable[str],
+    metrics: Iterable[str],
+) -> pd.DataFrame:
+    if history_df.empty:
+        return history_df
+
+    filtered = history_df.copy()
+    repos = list(repos)
+    classes = list(classes)
+    metrics = list(metrics)
+
+    if repos:
+        filtered = filtered[filtered["repo_id"].isin(repos)]
+    if classes:
+        filtered = filtered[filtered["class"].isin(classes)]
+    if metrics:
+        filtered = filtered[filtered["metric"].isin(metrics)]
+
+    return filtered
+
+
+def build_latest_snapshot_table(history_df: pd.DataFrame) -> pd.DataFrame:
+    if history_df.empty:
+        return pd.DataFrame()
+
+    latest_df = history_df[history_df["is_latest"]].copy()
+    if latest_df.empty:
+        return pd.DataFrame()
+
+    value_pivot = latest_df.pivot_table(
+        index=["repo_id", "class", "revision", "timestamp"],
+        columns="metric",
+        values="value",
+        aggfunc="first",
+    )
+    std_pivot = latest_df.pivot_table(
+        index=["repo_id", "class", "revision", "timestamp"],
+        columns="metric",
+        values="std",
+        aggfunc="first",
+    )
+
+    if not std_pivot.empty:
+        std_pivot.columns = [f"{column}_std" for column in std_pivot.columns]
+
+    snapshot = value_pivot.join(std_pivot, how="left")
+    snapshot = snapshot.reset_index().sort_values(["repo_id", "class"])
+    return snapshot
+
+
+def _normalize_key(value: str) -> str:
+    return re.sub(r"[^a-z0-9]", "", str(value).strip().lower())
+
+
+def _parse_float(value: object) -> float:
+    if value is None:
+        return np.nan
+
+    text = str(value).strip()
+    if text == "":
+        return np.nan
+
+    lowered = text.lower()
+    if lowered in {"nan", "na", "n/a", "none", "null", "-"}:
+        return np.nan
+
+    cleaned = text.replace(",", "")
+    try:
+        return float(cleaned)
+    except ValueError:
+        return np.nan