Fix download column

src/display/columns.py

@@ -83,7 +83,7 @@ def main_board_datatype_for_df(df: pd.DataFrame) -> list[str]:
     number_cols = set(_NUMBER_COLS) | {task.value.col_name for task in Tasks}
     result: list[str] = []
     for col in df.columns:
-        if col in (MODEL_COL, INTERNAL_MODEL_COL, DOWNLOAD_COL):
+        if col == DOWNLOAD_COL:
             result.append("markdown")
         elif col in number_cols:
             result.append("number")
@@ -97,11 +97,10 @@ def main_board_datatype_for_df(df: pd.DataFrame) -> list[str]:
 def main_board_datatype() -> list[str]:
     """Fallback datatype list for COLS + download column."""
     col_types = {c.name: c.type for c in fields(AutoEvalColumn)}
-    col_types[INTERNAL_MODEL_COL] = "markdown"
     types: list[str] = []
     for name in COLS:
         if name == INTERNAL_MODEL_COL:
-            types.append("markdown")
+            types.append("markdown")  # download column before model
         types.append(col_types[name])
     return types
 

src/display/datasets_tab.py

@@ -9,7 +9,7 @@ from src.populate import get_dataset_info_markdown, get_dataset_leaderboard_df
 def _dataset_datatype(task_name: str) -> list[str]:
     task = Tasks[task_name]
     metric_cols = get_dataset_metric_cols(task)
-    # download (markdown) + model (markdown) + team + metrics
+    # download (markdown) + model (markdown HTML link) + team + metrics
     return ["markdown", "markdown", "str"] + ["number"] * len(metric_cols)
 
 

src/display/formatting.py

@@ -1,21 +1,21 @@
 def make_clickable_model(model_name: str) -> str:
-    """Clickable model name as CommonMark (safe for Leaderboard markdown cells)."""
+    """HTML link used on Datasets tab tables."""
     link = f"https://huggingface.co/{model_name}"
-    # Escape markdown special chars in the label; keep the URL as-is.
-    label = (
-        str(model_name)
-        .replace("\\", "\\\\")
-        .replace("[", "\\[")
-        .replace("]", "\\]")
+    return (
+        f'<a target="_blank" href="{link}" '
+        f'style="color: var(--link-text-color); text-decoration: underline;'
+        f'text-decoration-style: dotted;">{model_name}</a>'
     )
-    return f"[{label}]({link})"
 
 
 def make_download_cell(download_url: str | None = None) -> str:
-    """Single download-arrow markdown link for a dedicated column."""
+    """Only the download arrow icon (HTML <a>, rendered by markdown columns)."""
     if not download_url:
         return ""
-    return f'[⬇️]({download_url} "Скачать сабмит")'
+    return (
+        f'<a href="{download_url}" target="_blank" rel="noopener noreferrer" '
+        f'download title="Скачать сабмит">⬇️</a>'
+    )
 
 
 def styled_error(error):

src/display/utils.py

@@ -20,7 +20,7 @@ class ColumnContent:
 ## Leaderboard columns
 class AutoEvalColumn:
     model_type_symbol = ColumnContent("T", "str", False, never_hidden=True)
-    model = ColumnContent("Model", "markdown", True, never_hidden=True)
+    model = ColumnContent("Model", "str", True, never_hidden=True)
     team = ColumnContent("Team", "str", True, never_hidden=True)
     average = ColumnContent("Total Score ⬆️", "number", True)
     model_type = ColumnContent("Type", "str", False)

src/leaderboard/store.py

@@ -37,10 +37,12 @@ def submission_zip_repo_path_for_model(model: str) -> str:
 
 
 def submission_download_url(model: str) -> str | None:
-    """Public Hugging Face URL for the stored submission ZIP, if available."""
+    """Hugging Face URL for the stored submission ZIP, if available."""
     from src.envs import RESULTS_DATASET_REPO
 
-    if not RESULTS_DATASET_REPO or not has_submission_zip(model):
+    if not RESULTS_DATASET_REPO:
+        return None
+    if not has_submission_zip(model) and not _submission_lists_archive(model):
         return None
     path = submission_zip_repo_path_for_model(model)
     return (
@@ -49,6 +51,18 @@ def submission_download_url(model: str) -> str | None:
     )
 
 
+def _submission_lists_archive(model: str) -> bool:
+    path = result_path_for_model(model)
+    if not os.path.isfile(path):
+        return False
+    try:
+        with open(path, encoding="utf-8") as fp:
+            payload = json.load(fp)
+    except Exception:
+        return False
+    return bool(payload.get("submission_archive"))
+
+
 def has_submission(model: str) -> bool:
     return os.path.isfile(result_path_for_model(model))
 

src/populate.py

@@ -22,37 +22,30 @@ from src.leaderboard.store import submission_download_url
 from src.leaderboard.sync import sync_results_from_hub
 
 
-def _with_model_links_and_downloads(df: pd.DataFrame, model_col: str) -> pd.DataFrame:
-    """Localize names, add download column, render model links as markdown."""
-    if model_col == AutoEvalColumn.model.name:
-        df = localize_main_leaderboard_df(df)
-        model_col = MODEL_COL
-    else:
-        df = localize_dataset_leaderboard_df(df)
-        model_col = MODEL_COL if MODEL_COL in df.columns else model_col
-
+def _attach_downloads(df: pd.DataFrame, model_col: str) -> pd.DataFrame:
+    """Add a download-icon column to the left of the model column."""
     if df.empty or model_col not in df.columns:
         return insert_download_column(df, [])
 
     models = df[model_col].tolist()
     downloads = [make_download_cell(submission_download_url(model)) for model in models]
-    df = insert_download_column(df, downloads)
-    df[model_col] = [make_clickable_model(model) for model in models]
-    return df
+    return insert_download_column(df, downloads)
 
 
 def get_leaderboard_df(cols: list, benchmark_cols: list) -> pd.DataFrame:
     rows = get_stored_eval_rows()
     if not rows:
-        empty = pd.DataFrame(columns=cols)
-        return _with_model_links_and_downloads(empty, AutoEvalColumn.model.name)
+        empty = localize_main_leaderboard_df(pd.DataFrame(columns=cols))
+        return _attach_downloads(empty, MODEL_COL)
 
     display_rows = [{k: v for k, v in row.items() if not k.startswith("_")} for row in rows]
     df = pd.DataFrame.from_records(display_rows)
     df = df.sort_values(by=[AutoEvalColumn.average.name], ascending=False)
     df = df[cols].round(decimals=2)
     df = df[has_no_nan_values(df, benchmark_cols)]
-    return _with_model_links_and_downloads(df, AutoEvalColumn.model.name)
+    # Keep plain model names (str); only the download column is markdown.
+    df = localize_main_leaderboard_df(df)
+    return _attach_downloads(df, MODEL_COL)
 
 
 def get_dataset_leaderboard_df(task_name: str) -> pd.DataFrame:
@@ -64,9 +57,8 @@ def get_dataset_leaderboard_df(task_name: str) -> pd.DataFrame:
 
     rows = get_stored_eval_rows()
     if not rows:
-        return _with_model_links_and_downloads(
-            pd.DataFrame(columns=columns), "model"
-        )
+        empty = localize_dataset_leaderboard_df(pd.DataFrame(columns=columns))
+        return _attach_downloads(empty, MODEL_COL)
 
     dataset_rows = []
     for row in rows:
@@ -79,23 +71,28 @@ def get_dataset_leaderboard_df(task_name: str) -> pd.DataFrame:
             continue
 
         dataset_row = {
-            "model": row["_model"],
+            "model": make_clickable_model(row["_model"]),
             "team": row[AutoEvalColumn.team.name],
+            "_model_id": row["_model"],
         }
         for col_name, value in metrics.items():
             dataset_row[col_name] = round(value, 2) if value is not None else None
         dataset_rows.append(dataset_row)
 
     if not dataset_rows:
-        return _with_model_links_and_downloads(
-            pd.DataFrame(columns=columns), "model"
-        )
+        empty = localize_dataset_leaderboard_df(pd.DataFrame(columns=columns))
+        return _attach_downloads(empty, MODEL_COL)
 
-    df = pd.DataFrame.from_records(dataset_rows, columns=columns)
+    df = pd.DataFrame.from_records(dataset_rows)
     if sort_col:
         df = df.sort_values(by=sort_col, ascending=False)
     df = df.reset_index(drop=True)
-    return _with_model_links_and_downloads(df, "model")
+
+    model_ids = df["_model_id"].tolist()
+    df = df.drop(columns=["_model_id"])
+    df = localize_dataset_leaderboard_df(df)
+    downloads = [make_download_cell(submission_download_url(model)) for model in model_ids]
+    return insert_download_column(df, downloads)
 
 
 def get_dataset_info_markdown(task_name: str) -> str:
@@ -116,7 +113,6 @@ def get_all_leaderboard_outputs():
     """Reload main and per-dataset tables from results/."""
     from src.display.utils import BENCHMARK_COLS, COLS
 
-    # get_leaderboard_df already localizes and attaches the download column.
     main_df = get_leaderboard_df(COLS, BENCHMARK_COLS)
     dataset_dfs = [get_dataset_leaderboard_df(task.name) for task in Tasks]
     return (main_df, *dataset_dfs)