"""The PRIMO pages, rendered as ``pm-*`` markup for ``gr.HTML`` blocks. Gradio has no card or rich-table component, so every page here is a string of HTML styled entirely by ``primo.css`` -- the rail, the board grid, the leaderboard tables and the tasks table. The functions are pure: they take the data the app already fetched (``Board`` objects, the results ``DataFrame``, the registry) and return a string, so they unit-test without Gradio or a network. Two rules hold everywhere: * Every string that comes from the registry or from a submission goes through ``html.escape`` -- board names, blurbs, disease names and, above all, the user-chosen model names that become table cells and column headers. * New submissions can carry a public institution, author-submission check and paper link. Private legacy ``hf_username`` values stay hidden. Public strings and links are validated and escaped before rendering. Navigation is reload-based: the rail is a column of ```` and ```` links, which costs a page load per click but buys shareable per-board URLs and needs no JavaScript, matching how the board cards have always worked. """ import math import numbers from html import escape from urllib.parse import urlparse import pandas as pd from boards import ( AREA_GROUP, CATEGORY_GROUP, GROUP_NOTE, MODALITY_GROUP, Board, OpenBoard, in_group, modality_label, open_in_group, ) from leaderboard import ModelCell, per_task_table, ranked_table, tasks_table, top_models SECTIONS = (MODALITY_GROUP, AREA_GROUP, CATEGORY_GROUP) N_TOP_MODELS = 3 BRAND = ( '' '' "PRIMObenchmark" ) FOOT_LINKS = ( ("tasks", "Tasks"), ("submit", "Submit a model"), ("contribute", "Contribute"), ("method", "Method"), ) NAME_COLUMNS = frozenset({"Model", "Best"}) STRONG_COLUMNS = frozenset({"Task"}) METRIC_COLUMNS = frozenset({"Metric"}) RIGHT_COLUMNS = frozenset({"Rank", "Patients"}) CHEVRON = ( '' ) # --------------------------------------------------------------------- rail def rail_html( boards: list[Board], active_slug: str | None, active_tab: str | None ) -> str: """The left navigation: brand, a collapsible "Boards" menu, then the foot links. The board groups live inside a ``
`` toggle so the four foot links (Tasks, Submit, Contribute, Method) stay visible without scrolling. The toggle is pure HTML/CSS, keeping navigation reload-based and JavaScript-free. ``active_slug`` highlights the board a visitor is on; ``active_tab`` highlights a foot link, and its absence means we are on a board or the overview, so the "Boards" menu is the active one. Open boards link to Contribute, mirroring the overview cards. """ on_boards = active_tab is None summary_cls = "pm-rail-summary pm-active" if on_boards else "pm-rail-summary" parts = [ '
', BRAND, '
', f'Boards{CHEVRON}', '
', ] for group in SECTIONS: cards, opens = in_group(boards, group), open_in_group(boards, group) if not cards and not opens: continue parts.append( f'

{escape(group)}

' ) for board in cards: cls = "pm-link pm-active" if board.slug == active_slug else "pm-link" parts.append( f'' f'{escape(board.name)}' f'{board.n_tasks}' ) for board in opens: parts.append( '' f'{escape(board.name)}' 'open' ) parts.append("
") parts.append("
") parts.append('
') for tab, label in FOOT_LINKS: cls = "pm-foot-link pm-active" if tab == active_tab else "pm-foot-link" parts.append( f'{escape(label)}' ) parts.append("
") return "".join(parts) # ------------------------------------------------------------------ boards def _leading(top) -> str: """The card's mini-ranking, with the same empty/baseline states as before. An empty board says "be the first"; a board held only by our baselines says "beat the baseline" instead, because "be the first" misleads once a PCA already holds a score. """ parts = ['

Leading (Elo)

'] if not top: parts.append( '

No ranked model yet. Be the first.

' ) return "".join(parts) for row in top: badge = ( ' baseline' if row.is_baseline else "" ) score = "n/a" if row.elo is None else str(row.elo) parts.append( f'

{escape(row.name)}{badge}' f' {score}

' ) return "".join(parts) def _live_card(board: Board, df: pd.DataFrame, by_id: dict[str, dict]) -> str: top = top_models(df, by_id, board, N_TOP_MODELS) return ( f'' f"

{escape(board.name)}

" f'

{board.n_tasks} tasks · {board.n_cohorts} cohorts
' f"{board.n_patients:,} patients · {board.n_diseases} diseases

" f'

{escape(board.blurb)}

' f"{_leading(top)}" ) def _open_card(board: OpenBoard) -> str: return ( '' f"

{escape(board.name)}

" '

OPEN · no cohort yet

' f'

{escape(board.blurb)}

' '

Propose a cohort →

' ) def render_boards(boards: list[Board], df: pd.DataFrame, by_id: dict[str, dict]) -> str: """The Boards overview: every board as a card, grouped by facet. Live cards link to their board and teaser their leaders; open cards state a gap and link to Contribute. A section counts its open slices so the page reads as showing its own gaps, not the registry as the whole territory. """ if not boards: return ( '

The task registry is ' "unavailable right now. Please retry in a moment.

" ) out = [ '

Leaderboards

', "

PRIMO evaluates representations of omics samples through " "drug-development-related tasks. Benchmarks are organized by data " "modality, therapeutic area, or task category.

", '
', ] for group in SECTIONS: cards, opens = in_group(boards, group), open_in_group(boards, group) if not cards and not opens: continue note = escape(GROUP_NOTE.get(group, "")) counter = f" · +{len(opens)} open" if opens else "" out.append( '
' f'

{escape(group)}

' f'

{note}{counter}

' ) out += [_live_card(b, df, by_id) for b in cards] out += [_open_card(b) for b in opens] out.append("
") out.append("
") return "".join(out) # ------------------------------------------------------------- html tables def _fmt_value(value, is_score: bool) -> str | None: """Display text for one cell; ``None`` marks a blank (``n/a``) cell.""" try: if pd.isna(value): return None except (TypeError, ValueError): pass if isinstance(value, str): return value if isinstance(value, numbers.Integral): return str(int(value)) if isinstance(value, numbers.Real): if not math.isfinite(float(value)): return None return f"{float(value):.3f}" if is_score else str(value) return str(value) def _model_cell_html(cell: ModelCell) -> str: """Render one model label, allowing only escaped HTTP(S) paper links.""" label = escape(str(cell)) parsed = urlparse(cell.paper_link) if parsed.scheme in {"http", "https"} and parsed.netloc: url = escape(cell.paper_link, quote=True) label = ( f'{label}' ) chip = ( ' ✓ Authors' if cell.is_author_submission else "" ) return label + chip def _score_columns(df: pd.DataFrame) -> list[str]: """Numeric columns to format and bold -- ``Rank`` is an index, not a score.""" return [c for c in df.select_dtypes("number").columns if c not in RIGHT_COLUMNS] def _bold_cells(df: pd.DataFrame, score_cols: list[str], axis: int) -> set: """Which ``(row, col)`` cells hold the best value. ``axis=0`` bolds the best model per column (the ranked table, read down); ``axis=1`` bolds the best model per row (the per-task table, read across). """ bold = set() if not score_cols: return bold if axis == 0: for col in score_cols: best = df[col].max(skipna=True) if pd.notna(best): for idx, value in df[col].items(): if pd.notna(value) and value == best: bold.add((idx, col)) else: for idx, row in df.iterrows(): present = {c: row[c] for c in score_cols if pd.notna(row[c])} if present: best = max(present.values()) bold.update((idx, c) for c, v in present.items() if v == best) return bold def _cell_class(col: str, is_score: bool, blank: bool) -> str: if col in NAME_COLUMNS: return "pm-name" if col in STRONG_COLUMNS: return "pm-strong" if col in METRIC_COLUMNS: return "pm-metric" if is_score or col in RIGHT_COLUMNS: return "pm-num pm-num--dim" if blank else "pm-num" return "" def _df_to_table(df: pd.DataFrame, bold_axis: int | None, empty: str) -> str: """Render a DataFrame as a ``pm-table``, escaping every header and cell.""" if df.empty: return f'

{escape(empty)}

' score_cols = _score_columns(df) bold = _bold_cells(df, score_cols, bold_axis) if bold_axis is not None else set() head = [] for index, col in enumerate(df.columns): align = ( ' style="text-align:right"' if col in score_cols or col in RIGHT_COLUMNS else "" ) head.append( f'{escape(str(col))}" ) body = [] for idx, row in df.iterrows(): cells = [] for col in df.columns: is_score = col in score_cols text = _fmt_value(row[col], is_score) cls = _cell_class(col, is_score, text is None) weight = ' style="font-weight:700"' if (idx, col) in bold else "" shown = ( _model_cell_html(row[col]) if isinstance(row[col], ModelCell) else "n/a" if text is None else escape(text) ) cells.append(f'{shown}') body.append(f"{''.join(cells)}") return ( '
' f"{''.join(head)}" f"{''.join(body)}
" ) # ------------------------------------------------------------------- board def _board_meta(board: Board) -> str: return ( f"{escape(board.blurb)} · {board.n_tasks} tasks · {board.n_cohorts} cohorts · " f"{board.n_patients:,} patients · {escape(modality_label(board.modality))}" ) def render_board(board: Board | None, df: pd.DataFrame, by_id: dict[str, dict]) -> str: """One board: title strip, the ranked leaderboard, then the per-task table.""" if board is None: return ( '

No board available

' "

The task registry could not be loaded. Please retry shortly.

" "
" ) ranked = _df_to_table( ranked_table(df, by_id, board), bold_axis=0, empty="No model has covered every task of this board yet. Be the first to submit.", ) per_task = _df_to_table( per_task_table(df, by_id, board), bold_axis=1, empty="No submission has scored on this board yet.", ) return ( '

Board

' f"

{escape(board.name)}

{_board_meta(board)}

" '
' '
' '

Ranked

' f'

Only models that covered all {board.n_tasks} tasks are ' "ranked by Elo. Elo compares models pairwise within each task and never " "compares AUROC with Pearson directly.

" f"
{ranked}
" '
' '

Per task

' '

Every submission, partial ones included. Read across a row.

' f"
{per_task}
" "
" ) # ------------------------------------------------------------------- tasks def render_tasks(by_id: dict[str, dict]) -> str: """The Tasks page: one scannable row per hidden target. Provenance is never shown.""" df = tasks_table(list(by_id.values())) table = _df_to_table( df, bold_axis=None, empty="The task registry is unavailable right now." ) return ( '

Tasks

' f"

{len(df)} hidden clinical targets. One fixed linear probe reads each " "one out of your embedding; the cohorts stay anonymous, the biology does " "not.

" f'
{table}
' )