Fix open model filter callback reliability (#38)

- Fix open model filter callback reliability (5c02fd06b29fccf7afb556e9f4eb5d647f6ea33e)

leaderboard_transformer.py

@@ -12,6 +12,38 @@ 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"},
@@ -109,42 +141,34 @@ def get_openhands_logo_images():
     images = []
     
     # Light mode logo (visible in light mode, hidden in dark mode)
-    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
+    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",
+        ))
     
     # Dark mode logo (hidden in light mode, visible in dark mode)
-    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
+    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",
+        ))
     
     return images
 
@@ -511,54 +535,50 @@ def create_scatter_chart(
         marker_info = get_marker_icon(model_name, openness, mark_by)
         logo_path = marker_info['path']
         
-        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
+        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"
+            ))
     
     # Add labels for frontier points only
     for row in frontier_rows:
@@ -1193,25 +1213,8 @@ 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]:
-        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
+        return get_asset_data_uri(path)
 
     # Composite markers: on the Alternative Agents page the dataframe carries
     # an "Agent" column (Claude Code / Codex / Gemini CLI / OpenHands Sub-agents),

ui_components.py

@@ -43,6 +43,8 @@ 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:
     """
@@ -81,12 +83,18 @@ 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")
-            return f"data:image/svg+xml;base64,{encoded_svg}"
+            uri = f"data:image/svg+xml;base64,{encoded_svg}"
+            _SVG_DATA_URI_CACHE[path] = uri
+            return uri
     except FileNotFoundError:
         print(f"Warning: SVG file not found at {path}")
+        _SVG_DATA_URI_CACHE[path] = ""
         return ""
 
 

visualizations.py

@@ -108,7 +108,17 @@ 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 = 'Openness' if 'Openness' in df.columns else 'openness'
+    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
     
     plot_df = df[
         (df[param_col].notna()) &