[AUTO] Fix scatter plot zoom and show_all_labels applied to main

app.py

@@ -2,7 +2,6 @@
 import logging
 import sys
 import os
-import json
 
 from constants import FONT_FAMILY_SHORT
 
@@ -385,7 +384,6 @@ logger.info("All routes configured")
 
 # Mount the REST API on /api
 from fastapi import FastAPI, Request
-from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import RedirectResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 from api import api_app
@@ -406,71 +404,6 @@ class RootRedirectMiddleware(BaseHTTPMiddleware):
         return await call_next(request)
 
 
-class StringifiedGradioJSONMiddleware:
-    """Normalize JSON bodies double-encoded by the custom-domain proxy.
-
-    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.
-    """
-
-    def __init__(self, app):
-        self.app = app
-
-    async def __call__(self, scope, receive, send):
-        if (
-            scope["type"] == "http"
-            and scope.get("method") == "POST"
-            and scope.get("path", "").startswith("/gradio_api/")
-        ):
-            headers = {
-                key.decode("latin-1").lower(): value.decode("latin-1")
-                for key, value in scope.get("headers", [])
-            }
-            content_type = headers.get("content-type", "")
-            if "application/json" not in content_type:
-                return await self.app(scope, receive, 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, send)
-
-        return await self.app(scope, receive, 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)
@@ -482,15 +415,6 @@ root_app.mount("/api", api_app)
 
 # Mount Gradio app at root path
 app = gr.mount_gradio_app(root_app, demo, path="/")
-app = CORSMiddleware(
-    app,
-    allow_origins=["https://index.openhands.dev"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-    expose_headers=["*"],
-)
-app = StringifiedGradioJSONMiddleware(app)
 logger.info("REST API mounted at /api, Gradio app mounted at /")
 
 
@@ -503,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:
@@ -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),

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()) &