Fix: Scatter plot zoom and 'Show all labels' not working

app.py

@@ -2,7 +2,6 @@
 import logging
 import sys
 import os
-import json
 
 from constants import FONT_FAMILY_SHORT
 
@@ -77,29 +76,6 @@ redirect_script = """
     if (window.location.pathname === '/') { window.location.replace('/home'); }
 </script>
 """
-hf_space_fetch_credentials_script = """
-<script>
-(function() {
-    const hfSpaceApiPrefix = "https://openhands-openhands-index.hf.space/gradio_api/";
-    const originalFetch = window.fetch.bind(window);
-
-    window.fetch = function(input, init) {
-        const url = typeof input === "string" ? input : input?.url;
-
-        if (url && url.startsWith(hfSpaceApiPrefix)) {
-            if (input instanceof Request) {
-                input = new Request(input, { ...(init || {}), credentials: "omit" });
-                init = undefined;
-            } else {
-                init = { ...(init || {}), credentials: "omit" };
-            }
-        }
-
-        return originalFetch(input, init);
-    };
-})();
-</script>
-"""
 
 # JavaScript to fix navigation links to use relative paths (avoids domain mismatch when behind proxy)
 fix_nav_links_script = """
@@ -376,15 +352,7 @@ logger.info("Creating Gradio application")
 demo = gr.Blocks(
     theme=theme,
     css=final_css,
-    head=(
-        hf_space_fetch_credentials_script
-        + posthog_script
-        + scroll_script
-        + redirect_script
-        + fix_nav_links_script
-        + tooltip_script
-        + dark_mode_script
-    ),
+    head=posthog_script + scroll_script + redirect_script + fix_nav_links_script + tooltip_script + dark_mode_script,
     title="OpenHands Index",
 )
 
@@ -436,119 +404,6 @@ class RootRedirectMiddleware(BaseHTTPMiddleware):
         return await call_next(request)
 
 
-class StringifiedGradioJSONMiddleware:
-    """Normalize custom-domain Gradio requests before they reach Gradio.
-
-    Requests sent through index.openhands.dev can arrive at Gradio as a JSON
-    string containing the real request object, which makes FastAPI validation
-    reject interactive callbacks with 422. Direct HF Space traffic already sends
-    proper JSON objects, so this only rewrites bodies that decode to strings.
-
-    The custom domain also loads the Gradio frontend from Vercel while
-    window.gradio_config.root points to the hf.space runtime. Chrome therefore
-    requires successful credentialed CORS preflights for queue and heartbeat
-    endpoints.
-    """
-
-    CUSTOM_DOMAIN_ORIGIN = "https://index.openhands.dev"
-
-    def __init__(self, app):
-        self.app = app
-
-    async def __call__(self, scope, receive, send):
-        origin = None
-        if scope["type"] == "http":
-            headers = {
-                key.decode("latin-1").lower(): value.decode("latin-1")
-                for key, value in scope.get("headers", [])
-            }
-            origin = headers.get("origin")
-
-        should_apply_cors = (
-            scope["type"] == "http"
-            and scope.get("path", "").startswith("/gradio_api/")
-            and origin == self.CUSTOM_DOMAIN_ORIGIN
-        )
-
-        if should_apply_cors:
-            cors_headers = [
-                (b"access-control-allow-origin", self.CUSTOM_DOMAIN_ORIGIN.encode("latin-1")),
-                (b"access-control-allow-credentials", b"true"),
-                (b"access-control-allow-methods", b"DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT"),
-                (b"access-control-allow-headers", b"*"),
-                (b"access-control-expose-headers", b"*"),
-                (b"vary", b"Origin"),
-            ]
-
-            if scope.get("method") == "OPTIONS":
-                await send({
-                    "type": "http.response.start",
-                    "status": 200,
-                    "headers": cors_headers,
-                })
-                await send({"type": "http.response.body", "body": b""})
-                return
-
-            async def cors_send(message):
-                if message["type"] == "http.response.start":
-                    message["headers"] = [
-                        (key, value)
-                        for key, value in message.get("headers", [])
-                        if not key.lower().startswith(b"access-control-")
-                        and key.lower() != b"vary"
-                    ] + cors_headers
-                await send(message)
-        else:
-            cors_send = send
-
-        if (
-            scope["type"] == "http"
-            and scope.get("method") == "POST"
-            and scope.get("path", "").startswith("/gradio_api/")
-        ):
-            content_type = headers.get("content-type", "")
-            if "application/json" not in content_type:
-                return await self.app(scope, receive, cors_send)
-
-            body_parts = []
-            while True:
-                message = await receive()
-                if message["type"] != "http.request":
-                    break
-                body_parts.append(message.get("body", b""))
-                if not message.get("more_body", False):
-                    break
-
-            body = b"".join(body_parts)
-            replacement_body = body
-            try:
-                decoded = json.loads(body)
-            except json.JSONDecodeError:
-                decoded = None
-
-            if isinstance(decoded, str):
-                stripped = decoded.strip()
-                if stripped.startswith(("{", "[")):
-                    replacement_body = stripped.encode("utf-8")
-
-            sent = False
-
-            async def replay_receive():
-                nonlocal sent
-                if sent:
-                    return {"type": "http.request", "body": b"", "more_body": False}
-                sent = True
-                return {
-                    "type": "http.request",
-                    "body": replacement_body,
-                    "more_body": False,
-                }
-
-            return await self.app(scope, replay_receive, cors_send)
-
-        return await self.app(scope, receive, cors_send)
-
-
 # Create a parent FastAPI app with redirect_slashes=False to prevent
 # automatic trailing slash redirects that cause issues with Gradio
 root_app = FastAPI(redirect_slashes=False)
@@ -560,7 +415,6 @@ root_app.mount("/api", api_app)
 
 # Mount Gradio app at root path
 app = gr.mount_gradio_app(root_app, demo, path="/")
-app = StringifiedGradioJSONMiddleware(app)
 logger.info("REST API mounted at /api, Gradio app mounted at /")
 
 
@@ -573,3 +427,4 @@ if __name__ == "__main__":
     logger.info(f"Launching app on {host}:{port}")
     uvicorn.run(app, host=host, port=port)
     logger.info("App launched successfully")
+

content.py

@@ -547,20 +547,19 @@ span.wrap[tabindex="0"][role="button"][data-editable="false"] {
     width: 100% !important;
     align-items: center;
 }
-.nav-holder nav a[href*="alternative-agents"] {
-    grid-row: 1 !important;
-    grid-column: 7 !important;
-    white-space: nowrap !important;
-}
 .nav-holder nav a[href*="about"] {
     grid-row: 1 !important;
-    grid-column: 8 !important;
+    grid-column: 7 !important;
 }
 .nav-holder nav a[href*="submit"] {
     grid-row: 1 !important;
     grid-column: 8 !important;
     white-space: nowrap !important;
 }
+/* Hide the Alternative Agents page from the top-level nav for now. */
+.nav-holder nav a[href*="alternative-agents"] {
+    display: none !important;
+}
 
 /* Divider line between header and category nav */
 .nav-holder nav::after {
@@ -599,7 +598,6 @@ span.wrap[tabindex="0"][role="button"][data-editable="false"] {
 .nav-holder nav a[href*="discovery"] { grid-column: 4 !important; }
 
 /* Navigation hover styles */
-.nav-holder nav a[href*="alternative-agents"]:hover,
 .nav-holder nav a[href*="about"]:hover,
 .nav-holder nav a[href*="submit"]:hover,
 .nav-holder nav a[href*="literature-understanding"]:hover,
@@ -609,7 +607,6 @@ span.wrap[tabindex="0"][role="button"][data-editable="false"] {
     background-color: #FDF9F4;
 }
 
-.dark .nav-holder nav a[href*="alternative-agents"]:hover,
 .dark .nav-holder nav a[href*="about"]:hover,
 .dark .nav-holder nav a[href*="submit"]:hover,
 .dark .nav-holder nav a[href*="literature-understanding"]:hover,

leaderboard_transformer.py

@@ -12,38 +12,6 @@ from constants import FONT_FAMILY, FONT_FAMILY_SHORT
 
 logger = logging.getLogger(__name__)
 
-_DATA_URI_CACHE: dict[str, str] = {}
-
-
-def get_asset_data_uri(path: str) -> Optional[str]:
-    """Return a cached data URI for a local image asset."""
-    if path in _DATA_URI_CACHE:
-        return _DATA_URI_CACHE[path]
-
-    if not os.path.exists(path):
-        _DATA_URI_CACHE[path] = ""
-        return None
-
-    try:
-        with open(path, "rb") as f:
-            encoded = base64.b64encode(f.read()).decode("utf-8")
-    except Exception as e:
-        logger.warning(f"Could not load image asset {path}: {e}")
-        _DATA_URI_CACHE[path] = ""
-        return None
-
-    ext = os.path.splitext(path)[1].lower()
-    if ext == ".svg":
-        mime = "image/svg+xml"
-    elif ext == ".png":
-        mime = "image/png"
-    else:
-        mime = "application/octet-stream"
-
-    uri = f"data:{mime};base64,{encoded}"
-    _DATA_URI_CACHE[path] = uri
-    return uri
-
 # Company logo mapping for graphs - maps model name patterns to company logo files
 COMPANY_LOGO_MAP = {
     "anthropic": {"path": "assets/logo-anthropic.svg", "name": "Anthropic"},
@@ -141,34 +109,42 @@ def get_openhands_logo_images():
     images = []
     
     # Light mode logo (visible in light mode, hidden in dark mode)
-    light_logo_uri = get_asset_data_uri(OPENHANDS_LOGO_PATH_LIGHT)
-    if light_logo_uri:
-        images.append(dict(
-            source=light_logo_uri.replace("data:image/png;base64,", "data:image/png;openhands=lightlogo;base64,"),
-            xref="paper",
-            yref="paper",
-            x=0,
-            y=-0.15,
-            sizex=0.15,
-            sizey=0.15,
-            xanchor="left",
-            yanchor="bottom",
-        ))
+    if os.path.exists(OPENHANDS_LOGO_PATH_LIGHT):
+        try:
+            with open(OPENHANDS_LOGO_PATH_LIGHT, "rb") as f:
+                logo_data = base64.b64encode(f.read()).decode('utf-8')
+            images.append(dict(
+                source=f"data:image/png;openhands=lightlogo;base64,{logo_data}",
+                xref="paper",
+                yref="paper",
+                x=0,
+                y=-0.15,
+                sizex=0.15,
+                sizey=0.15,
+                xanchor="left",
+                yanchor="bottom",
+            ))
+        except Exception:
+            pass
     
     # Dark mode logo (hidden in light mode, visible in dark mode)
-    dark_logo_uri = get_asset_data_uri(OPENHANDS_LOGO_PATH_DARK)
-    if dark_logo_uri:
-        images.append(dict(
-            source=dark_logo_uri.replace("data:image/png;base64,", "data:image/png;openhands=darklogo;base64,"),
-            xref="paper",
-            yref="paper",
-            x=0,
-            y=-0.15,
-            sizex=0.15,
-            sizey=0.15,
-            xanchor="left",
-            yanchor="bottom",
-        ))
+    if os.path.exists(OPENHANDS_LOGO_PATH_DARK):
+        try:
+            with open(OPENHANDS_LOGO_PATH_DARK, "rb") as f:
+                logo_data = base64.b64encode(f.read()).decode('utf-8')
+            images.append(dict(
+                source=f"data:image/png;openhands=darklogo;base64,{logo_data}",
+                xref="paper",
+                yref="paper",
+                x=0,
+                y=-0.15,
+                sizex=0.15,
+                sizey=0.15,
+                xanchor="left",
+                yanchor="bottom",
+            ))
+        except Exception:
+            pass
     
     return images
 
@@ -535,50 +511,54 @@ def create_scatter_chart(
         marker_info = get_marker_icon(model_name, openness, mark_by)
         logo_path = marker_info['path']
         
-        logo_uri = get_asset_data_uri(logo_path)
-        if not logo_uri:
-            continue
-
-        if x_type == "date":
-            # For date axes, use data coordinates directly
-            layout_images.append(dict(
-                source=logo_uri,
-                xref="x",
-                yref="y",
-                x=x_val,
-                y=y_val,
-                sizex=15 * 24 * 60 * 60 * 1000,  # ~15 days in milliseconds
-                sizey=3,  # score units
-                xanchor="center",
-                yanchor="middle",
-                layer="above"
-            ))
-        else:
-            # For log axes, use domain coordinates (0-1 range)
-            if x_type == "log" and x_val > 0:
-                log_x = np.log10(x_val)
-                domain_x = (log_x - x_range_log[0]) / (x_range_log[1] - x_range_log[0])
-            else:
-                domain_x = 0.5
-
-            domain_y = (y_val - y_range[0]) / (y_range[1] - y_range[0]) if (y_range[1] - y_range[0]) > 0 else 0.5
-
-            # Clamp to valid range
-            domain_x = max(0, min(1, domain_x))
-            domain_y = max(0, min(1, domain_y))
-
-            layout_images.append(dict(
-                source=logo_uri,
-                xref="x domain",
-                yref="y domain",
-                x=domain_x,
-                y=domain_y,
-                sizex=0.04,
-                sizey=0.06,
-                xanchor="center",
-                yanchor="middle",
-                layer="above"
-            ))
+        if os.path.exists(logo_path):
+            try:
+                with open(logo_path, 'rb') as f:
+                    encoded_logo = base64.b64encode(f.read()).decode('utf-8')
+                logo_uri = f"data:image/svg+xml;base64,{encoded_logo}"
+                
+                if x_type == "date":
+                    # For date axes, use data coordinates directly
+                    layout_images.append(dict(
+                        source=logo_uri,
+                        xref="x",
+                        yref="y",
+                        x=x_val,
+                        y=y_val,
+                        sizex=15 * 24 * 60 * 60 * 1000,  # ~15 days in milliseconds
+                        sizey=3,  # score units
+                        xanchor="center",
+                        yanchor="middle",
+                        layer="above"
+                    ))
+                else:
+                    # For log axes, use domain coordinates (0-1 range)
+                    if x_type == "log" and x_val > 0:
+                        log_x = np.log10(x_val)
+                        domain_x = (log_x - x_range_log[0]) / (x_range_log[1] - x_range_log[0])
+                    else:
+                        domain_x = 0.5
+                    
+                    domain_y = (y_val - y_range[0]) / (y_range[1] - y_range[0]) if (y_range[1] - y_range[0]) > 0 else 0.5
+                    
+                    # Clamp to valid range
+                    domain_x = max(0, min(1, domain_x))
+                    domain_y = max(0, min(1, domain_y))
+                    
+                    layout_images.append(dict(
+                        source=logo_uri,
+                        xref="x domain",
+                        yref="y domain",
+                        x=domain_x,
+                        y=domain_y,
+                        sizex=0.04,
+                        sizey=0.06,
+                        xanchor="center",
+                        yanchor="middle",
+                        layer="above"
+                    ))
+            except Exception:
+                pass
     
     # Add labels for frontier points only
     for row in frontier_rows:
@@ -991,7 +971,7 @@ def _plot_scatter_plotly(
         name: Optional[str] = None,
         plot_type: str = 'cost',  # 'cost' or 'runtime'
         mark_by: Optional[str] = None,  # 'Company', 'Openness', or 'Country'
-        show_all_labels: bool = False  # Show labels for all points vs only Pareto frontier
+        show_all_labels: bool = False
 ) -> go.Figure:
     from constants import MARK_BY_DEFAULT
     if mark_by is None:
@@ -1213,8 +1193,25 @@ def _plot_scatter_plotly(
     y_min = min_score - 5 if min_score > 5 else 0
     y_max = max_score + 5
     
+    # Cache base64-encoded logos across rows — every Claude model on the
+    # Alternative Agents page points at the same assets/harness-claude-code.svg,
+    # so decoding once per path is ~N× cheaper than once per point.
+    _logo_cache: dict[str, str] = {}
     def _encode_logo(path: str) -> Optional[str]:
-        return get_asset_data_uri(path)
+        if path in _logo_cache:
+            return _logo_cache[path]
+        if not os.path.exists(path):
+            return None
+        try:
+            with open(path, "rb") as f:
+                encoded = base64.b64encode(f.read()).decode("utf-8")
+        except Exception as e:
+            logger.warning(f"Could not load logo {path}: {e}")
+            return None
+        mime = "svg+xml" if path.lower().endswith(".svg") else "png"
+        uri = f"data:image/{mime};base64,{encoded}"
+        _logo_cache[path] = uri
+        return uri
 
     # Composite markers: on the Alternative Agents page the dataframe carries
     # an "Agent" column (Claude Code / Codex / Gemini CLI / OpenHands Sub-agents),
@@ -1271,107 +1268,93 @@ def _plot_scatter_plotly(
         domain_x = max(0, min(1, domain_x))
         domain_y = max(0, min(1, domain_y))
 
-        # Convert to data coordinates
-        # For log scale x: use log10(x) to match the axis type
-        x_log = np.log10(x_val) if x_val > 0 else x_min_log
-
         if harness_uri is not None:
-            # Composite: stack model on top, harness on bottom
-            # Use data coordinates (x, y) so logos zoom/pan together with labels
-            y_offset = 0.8  # Offset above the data point (in score units)
+            # Composite: stack model on top, harness on bottom, clamping
+            # each half to the plot area so markers near the edges don't
+            # drift off-canvas.
+            model_y = min(1, domain_y + STACKED_Y_OFFSET)
+            harness_y = max(0, domain_y - STACKED_Y_OFFSET)
             layout_images.append(dict(
                 source=model_logo_uri,
-                xref="x", yref="y",
-                x=x_log, y=y_val + y_offset,
-                sizex=STACKED_SIZE_X * (x_max_log - x_min_log), 
-                sizey=STACKED_SIZE_Y * (y_max - y_min),
+                xref="x domain", yref="y domain",
+                x=domain_x, y=model_y,
+                sizex=STACKED_SIZE_X, sizey=STACKED_SIZE_Y,
                 xanchor="center", yanchor="middle",
                 layer="above",
             ))
             layout_images.append(dict(
                 source=harness_uri,
-                xref="x", yref="y",
-                x=x_log, y=y_val - y_offset,
-                sizex=STACKED_SIZE_X * (x_max_log - x_min_log),
-                sizey=STACKED_SIZE_Y * (y_max - y_min),
+                xref="x domain", yref="y domain",
+                x=domain_x, y=harness_y,
+                sizex=STACKED_SIZE_X, sizey=STACKED_SIZE_Y,
                 xanchor="center", yanchor="middle",
                 layer="above",
             ))
         else:
-            # Single marker - use data coordinates so logo zooms/pans with labels
+            # Single marker (canonical OpenHands pages, or Alternative Agents
+            # rows with an unknown harness name — the latter shouldn't happen
+            # in practice since HARNESS_LOGO_PATHS covers every agent_name the
+            # push-to-index script emits).
             layout_images.append(dict(
                 source=model_logo_uri,
-                xref="x", yref="y",
-                x=x_log, y=y_val,
-                sizex=SINGLE_SIZE_X * (x_max_log - x_min_log), 
-                sizey=SINGLE_SIZE_Y * (y_max - y_min),
+                xref="x domain", yref="y domain",
+                x=domain_x, y=domain_y,
+                sizex=SINGLE_SIZE_X, sizey=SINGLE_SIZE_Y,
                 xanchor="center", yanchor="middle",
                 layer="above",
             ))
 
-    # --- Section 7: Add Model Name Labels ---
-    # Show labels for all points if show_all_labels is True, otherwise just Pareto frontier
-    if show_all_labels:
-        # Label all data points
-        labels_data = []
-        for _, row in data_plot.iterrows():
-            x_val = row[x_col_to_use]
-            y_val = row[y_col_to_use]
-            
-            model_name = row.get('Language Model', '')
-            if isinstance(model_name, list):
-                model_name = model_name[0] if model_name else ''
-            model_name = str(model_name).split('/')[-1]
-            if len(model_name) > 25:
-                model_name = model_name[:22] + '...'
-            
-            labels_data.append({'x': x_val, 'y': y_val, 'label': model_name})
-    elif frontier_rows:
-        # Label only Pareto frontier points
-        labels_data = []
+    # --- Section 7: Add Model Name Labels to Frontier Points ---
+    if frontier_rows:
+        frontier_labels_data = []
         
         for row in frontier_rows:
             x_val = row[x_col_to_use]
             y_val = row[y_col_to_use]
             
+            # Get the model name for the label
             model_name = row.get('Language Model', '')
             if isinstance(model_name, list):
                 model_name = model_name[0] if model_name else ''
+            # Clean the model name (remove path prefixes)
             model_name = str(model_name).split('/')[-1]
+            # Truncate long names
             if len(model_name) > 25:
                 model_name = model_name[:22] + '...'
             
-            labels_data.append({'x': x_val, 'y': y_val, 'label': model_name})
-    else:
-        labels_data = []
-    
-    # Add annotations for each label
-    # For log scale x-axis, annotations need log10(x) coordinates (Plotly issue #2580)
-    for item in labels_data:
-        x_val = item['x']
-        y_val = item['y']
-        label = item['label']
-        
-        # Transform x to log10 for annotation positioning on log scale
-        if x_val > 0:
-            x_log = np.log10(x_val)
-        else:
-            x_log = x_min_log
+            frontier_labels_data.append({
+                'x': x_val,
+                'y': y_val,
+                'label': model_name
+            })
         
-        fig.add_annotation(
-            x=x_log,
-            y=y_val,
-            text=label,
-            showarrow=False,
-            yshift=25,  # Move label higher above the icon
-            font=dict(
-                size=10,
-                color='#0D0D0F',  # neutral-950
-                family=FONT_FAMILY_SHORT
-            ),
-            xanchor='center',
-            yanchor='bottom'
-        )
+        # Add annotations for each frontier label
+        # For log scale x-axis, annotations need log10(x) coordinates (Plotly issue #2580)
+        for item in frontier_labels_data:
+            x_val = item['x']
+            y_val = item['y']
+            label = item['label']
+            
+            # Transform x to log10 for annotation positioning on log scale
+            if x_val > 0:
+                x_log = np.log10(x_val)
+            else:
+                x_log = x_min_log
+            
+            fig.add_annotation(
+                x=x_log,
+                y=y_val,
+                text=label,
+                showarrow=False,
+                yshift=25,  # Move label higher above the icon
+                font=dict(
+                    size=10,
+                    color='#0D0D0F',  # neutral-950
+                    family=FONT_FAMILY_SHORT
+                ),
+                xanchor='center',
+                yanchor='bottom'
+            )
 
     # --- Section 8: Configure Layout  ---
     # Use the same axis ranges as calculated for domain coordinates
@@ -1490,38 +1473,47 @@ def format_score_column(df: pd.DataFrame, score_col_name: str) -> pd.DataFrame:
     return df.assign(**{score_col_name: df[score_col_name].apply(apply_formatting)})
 
 
+def _hidden_runtime_sort_key(runtime_value: float | int | None, score_value: float | int | None) -> str:
+    """Build a hidden prefix so Gradio's string-based runtime sorting behaves numerically."""
+    if pd.notna(runtime_value) and isinstance(runtime_value, (int, float)):
+        return f"{float(runtime_value):020.6f}"
+    if pd.notna(score_value):
+        return "99999999999999999998"
+    return "99999999999999999999"
+
+
 def format_runtime_column(df: pd.DataFrame, runtime_col_name: str) -> pd.DataFrame:
     """
     Applies custom formatting to a runtime column based on its corresponding score column.
     - If runtime is not null, formats as time with 's' suffix.
     - If runtime is null but score is not, it becomes "Missing".
     - If both runtime and score are null, it becomes "Not Submitted".
+    - Adds a hidden, zero-padded numeric prefix so Gradio sorts the column numerically.
     Args:
         df: The DataFrame to modify.
         runtime_col_name: The name of the runtime column to format (e.g., "Average Runtime").
     Returns:
         The DataFrame with the formatted runtime column.
     """
-    # Find the corresponding score column by replacing "Runtime" with "Score"
     score_col_name = runtime_col_name.replace("Runtime", "Score")
 
-    # Ensure the score column actually exists to avoid errors
     if score_col_name not in df.columns:
-        return df  # Return the DataFrame unmodified if there's no matching score
+        return df
 
     def apply_formatting_logic(row):
         runtime_value = row[runtime_col_name]
         score_value = row[score_col_name]
         status_color = "#ec4899"
+        sort_key = _hidden_runtime_sort_key(runtime_value, score_value)
+        hidden_sort_prefix = f'<span style="display:none">{sort_key}</span>'
 
         if pd.notna(runtime_value) and isinstance(runtime_value, (int, float)):
-            return f"{runtime_value:.0f}s"
+            return f"{hidden_sort_prefix}{runtime_value:.0f}s"
         elif pd.notna(score_value):
-            return f'<span style="color: {status_color};">Missing</span>'  # Score exists, but runtime is missing
+            return f'{hidden_sort_prefix}<span style="color: {status_color};">Missing</span>'
         else:
-            return f'<span style="color: {status_color};">Not Submitted</span>'  # Neither score nor runtime exists
+            return f'{hidden_sort_prefix}<span style="color: {status_color};">Not Submitted</span>'
 
-    # Apply the logic to the specified runtime column and update the DataFrame
     df[runtime_col_name] = df.apply(apply_formatting_logic, axis=1)
 
     return df

simple_data_loader.py

@@ -245,6 +245,7 @@ class SimpleLeaderboardViewer:
                 'acp-claude': 'Claude Code',
                 'acp-codex': 'Codex',
                 'acp-gemini': 'Gemini CLI',
+                'openhands_subagents': 'OpenHands Sub-agents',
             }
             alt_dir = self.config_path / "alternative_agents"
             if alt_dir.exists():
@@ -252,8 +253,6 @@ class SimpleLeaderboardViewer:
                     if not type_dir.is_dir():
                         continue
                     default_name = agent_type_default_name.get(type_dir.name)
-                    if default_name is None:
-                        continue  # skip unlisted agent types (e.g. openhands_subagents)
                     for agent_dir in type_dir.iterdir():
                         if not agent_dir.is_dir():
                             continue

ui_components.py

@@ -43,8 +43,6 @@ from content import (
 api = HfApi()
 os.makedirs(EXTRACTED_DATA_DIR, exist_ok=True)
 
-_SVG_DATA_URI_CACHE: dict[str, str] = {}
-
 
 def get_company_logo_html(model_name: str) -> str:
     """
@@ -83,18 +81,12 @@ OPENNESS_SVG_MAP = {
 
 def get_svg_as_data_uri(path: str) -> str:
     """Reads an SVG file and returns it as a base64-encoded data URI."""
-    if path in _SVG_DATA_URI_CACHE:
-        return _SVG_DATA_URI_CACHE[path]
-
     try:
         with open(path, "rb") as svg_file:
             encoded_svg = base64.b64encode(svg_file.read()).decode("utf-8")
-            uri = f"data:image/svg+xml;base64,{encoded_svg}"
-            _SVG_DATA_URI_CACHE[path] = uri
-            return uri
+            return f"data:image/svg+xml;base64,{encoded_svg}"
     except FileNotFoundError:
         print(f"Warning: SVG file not found at {path}")
-        _SVG_DATA_URI_CACHE[path] = ""
         return ""
 
 
@@ -962,7 +954,7 @@ def create_leaderboard_display(
             if not new_df.empty:
                 new_transformer = DataTransformer(new_df, new_tag_map)
                 new_df_view_full, _ = new_transformer.view(tag=category_name, use_plotly=True)
-
+                
                 # Prepare both complete and all entries versions
                 if 'Categories Attempted' in new_df_view_full.columns:
                     new_df_view_complete = new_df_view_full[new_df_view_full['Categories Attempted'] == '5/5'].copy()
@@ -1022,22 +1014,16 @@ def create_leaderboard_display(
     
     # Connect the timer to the refresh function
     if show_incomplete_checkbox is not None:
+        timer_inputs = [show_incomplete_checkbox]
         if show_open_only_checkbox is not None:
-            refresh_timer.tick(
-                fn=check_and_refresh_data,
-                inputs=[show_incomplete_checkbox, show_open_only_checkbox, mark_by_dropdown, show_all_labels_checkbox],
-                outputs=[dataframe_component, cost_plot_component, runtime_plot_component]
-            )
-        else:
-            # No open/closed split in this dataset — gr.State can't fill the gap in a
-            # timer tick (no session context), so use a wrapper that fixes show_open_only=False.
-            def _timer_refresh_no_open(show_incomplete, mark_by, show_all_labels):
-                return check_and_refresh_data(show_incomplete, False, mark_by, show_all_labels)
-            refresh_timer.tick(
-                fn=_timer_refresh_no_open,
-                inputs=[show_incomplete_checkbox, mark_by_dropdown, show_all_labels_checkbox],
-                outputs=[dataframe_component, cost_plot_component, runtime_plot_component]
-            )
+            timer_inputs.append(show_open_only_checkbox)
+        timer_inputs.append(mark_by_dropdown)  # Always include mark_by
+        timer_inputs.append(show_all_labels_checkbox)
+        refresh_timer.tick(
+            fn=check_and_refresh_data,
+            inputs=timer_inputs,
+            outputs=[dataframe_component, cost_plot_component, runtime_plot_component]
+        )
     else:
         # If no incomplete checkbox, always show all data (but still filter by open if needed)
         def check_and_refresh_all(show_open_only=False, mark_by=MARK_BY_DEFAULT, show_all_labels=False):

visualizations.py

@@ -108,17 +108,7 @@ def create_accuracy_by_size_chart(df: pd.DataFrame, mark_by: str = None) -> go.F
     open_aliases = [aliases.CANONICAL_OPENNESS_OPEN] + list(
         aliases.OPENNESS_ALIASES.get(aliases.CANONICAL_OPENNESS_OPEN, [])
     )
-    openness_col = _find_column(df, ['Openness', 'openness'])
-    if openness_col is None:
-        fig = go.Figure()
-        fig.add_annotation(
-            text="No openness data available",
-            xref="paper", yref="paper",
-            x=0.5, y=0.5, showarrow=False,
-            font=STANDARD_FONT
-        )
-        fig.update_layout(**STANDARD_LAYOUT, title="Open Model Accuracy by Size")
-        return fig
+    openness_col = 'Openness' if 'Openness' in df.columns else 'openness'
     
     plot_df = df[
         (df[param_col].notna()) &