workbench 0.8.219__py3-none-any.whl → 0.8.231__py3-none-any.whl

workbench/utils/chem_utils/vis.py

@@ -2,32 +2,122 @@
 
 import logging
 import base64
-import re
 from typing import Optional, Tuple
 from rdkit import Chem
 from rdkit.Chem import AllChem, Draw
 from rdkit.Chem.Draw import rdMolDraw2D
+from dash import html
+
+# Workbench Imports
+from workbench.utils.color_utils import is_dark
 
 # Set up the logger
 log = logging.getLogger("workbench")
 
 
-def _is_dark(color: str) -> bool:
-    """Determine if an rgba color is dark based on RGB average.
+def molecule_hover_tooltip(
+    smiles: str, mol_id: str = None, width: int = 300, height: int = 200, background: str = None
+) -> list:
+    """Generate a molecule hover tooltip from a SMILES string.
+
+    This function creates a visually appealing tooltip with a dark background
+    that displays the molecule ID at the top and structure below when hovering
+    over scatter plot points.
 
     Args:
-        color: Color in rgba(...) format
+        smiles: SMILES string representing the molecule
+        mol_id: Optional molecule ID to display at the top of the tooltip
+        width: Width of the molecule image in pixels (default: 300)
+        height: Height of the molecule image in pixels (default: 200)
+        background: Optional background color (if None, uses dark gray)
 
     Returns:
-        True if the color is dark, False otherwise
+        list: A list containing an html.Div with the ID header and molecule SVG,
+              or an html.Div with an error message if rendering fails
     """
-    match = re.match(r"rgba?\((\d+),\s*(\d+),\s*(\d+)", color)
-    if not match:
-        log.warning(f"Invalid color format: {color}, defaulting to dark")
-        return True  # Default to dark mode on error
+    try:
 
-    r, g, b = map(int, match.groups())
-    return (r + g + b) / 3 < 128
+        # Use provided background or default to dark gray
+        if background is None:
+            background = "rgba(64, 64, 64, 1)"
+
+        # Generate the SVG image from SMILES (base64 encoded data URI)
+        img = svg_from_smiles(smiles, width, height, background=background)
+
+        if img is None:
+            log.warning(f"Could not render molecule for SMILES: {smiles}")
+            return [
+                html.Div(
+                    "Invalid SMILES",
+                    className="custom-tooltip",
+                    style={
+                        "padding": "10px",
+                        "color": "rgb(255, 140, 140)",
+                        "width": f"{width}px",
+                        "height": f"{height}px",
+                        "display": "flex",
+                        "alignItems": "center",
+                        "justifyContent": "center",
+                    },
+                )
+            ]
+
+        # Build the tooltip with ID header and molecule image
+        children = []
+
+        # Add ID header if provided
+        if mol_id is not None:
+            # Set text color based on background brightness
+            text_color = "rgb(200, 200, 200)" if is_dark(background) else "rgb(60, 60, 60)"
+            children.append(
+                html.Div(
+                    str(mol_id),
+                    style={
+                        "textAlign": "center",
+                        "padding": "8px",
+                        "color": text_color,
+                        "fontSize": "14px",
+                        "fontWeight": "bold",
+                        "borderBottom": "1px solid rgba(128, 128, 128, 0.5)",
+                    },
+                )
+            )
+
+        # Add molecule image
+        children.append(
+            html.Img(
+                src=img,
+                style={"padding": "0px", "margin": "0px", "display": "block"},
+                width=str(width),
+                height=str(height),
+            )
+        )
+
+        return [
+            html.Div(
+                children,
+                className="custom-tooltip",
+                style={"padding": "0px", "margin": "0px"},
+            )
+        ]
+
+    except ImportError as e:
+        log.error(f"RDKit not available for molecule rendering: {e}")
+        return [
+            html.Div(
+                "RDKit not installed",
+                className="custom-tooltip",
+                style={
+                    "padding": "10px",
+                    "color": "rgb(255, 195, 140)",
+                    "width": f"{width}px",
+                    "height": f"{height}px",
+                    "display": "flex",
+                    "alignItems": "center",
+                    "justifyContent": "center",
+                },
+            )
+        ]
 
 
 def _rgba_to_tuple(rgba: str) -> Tuple[float, float, float, float]:
@@ -75,7 +165,13 @@ def _configure_draw_options(options: Draw.MolDrawOptions, background: str) -> No
         options: RDKit drawing options object
         background: Background color string
     """
-    if _is_dark(background):
+    try:
+        if is_dark(background):
+            rdMolDraw2D.SetDarkMode(options)
+        # Light backgrounds use RDKit defaults (no action needed)
+    except ValueError:
+        # Default to dark mode if color format is invalid
+        log.warning(f"Invalid color format: {background}, defaulting to dark mode")
         rdMolDraw2D.SetDarkMode(options)
     options.setBackgroundColour(_rgba_to_tuple(background))
 
@@ -137,7 +233,7 @@ def svg_from_smiles(
     drawer.DrawMolecule(mol)
     drawer.FinishDrawing()
 
-    # Encode SVG
+    # Encode SVG as base64 data URI
     svg = drawer.GetDrawingText()
     encoded_svg = base64.b64encode(svg.encode("utf-8")).decode("utf-8")
     return f"data:image/svg+xml;base64,{encoded_svg}"
@@ -222,7 +318,7 @@ if __name__ == "__main__":
     # Test 6: Color parsing functions
     print("\n6. Testing color utility functions...")
     test_colors = [
-        ("invalid_color", True, (0.25, 0.25, 0.25, 1.0)),  # Should use defaults
+        ("invalid_color", None, (0.25, 0.25, 0.25, 1.0)),  # Should raise ValueError
         ("rgba(255, 255, 255, 1)", False, (1.0, 1.0, 1.0, 1.0)),
         ("rgba(0, 0, 0, 1)", True, (0.0, 0.0, 0.0, 1.0)),
         ("rgba(64, 64, 64, 0.5)", True, (0.251, 0.251, 0.251, 0.5)),
@@ -230,24 +326,38 @@ if __name__ == "__main__":
     ]
 
     for color, expected_dark, expected_tuple in test_colors:
-        is_dark_result = _is_dark(color)
-        tuple_result = _rgba_to_tuple(color)
-
-        dark_status = "✓" if is_dark_result == expected_dark else "✗"
-        print(f"   {dark_status} is_dark('{color[:20]}...'): {is_dark_result} == {expected_dark}")
+        try:
+            is_dark_result = is_dark(color)
+            if expected_dark is None:
+                print(f"   ✗ is_dark('{color[:20]}...'): Expected ValueError but got {is_dark_result}")
+            else:
+                dark_status = "✓" if is_dark_result == expected_dark else "✗"
+                print(f"   {dark_status} is_dark('{color[:20]}...'): {is_dark_result} == {expected_dark}")
+        except ValueError:
+            if expected_dark is None:
+                print(f"   ✓ is_dark('{color[:20]}...'): Correctly raised ValueError")
+            else:
+                print(f"   ✗ is_dark('{color[:20]}...'): Unexpected ValueError")
 
+        tuple_result = _rgba_to_tuple(color)
         # Check tuple values with tolerance for floating point
         tuple_match = all(abs(a - b) < 0.01 for a, b in zip(tuple_result, expected_tuple))
         tuple_status = "✓" if tuple_match else "✗"
         print(f"   {tuple_status} rgba_to_tuple('{color[:20]}...'): matches expected")
 
-    # Test the show function (will open image windows)
-    print("\n7. Testing show function (will open image windows)...")
-    try:
-        show(test_molecules["aspirin"])
-        show(test_molecules["aspirin"], background="rgba(220, 220, 220, 1)")
-        print("   ✓ show() function executed (check for image window)")
-    except Exception as e:
-        print(f"   ✗ show() function failed: {e}")
+    # Test the tooltip generation in a simple Dash app
+    from dash import Dash
+
+    app = Dash(__name__)
+    app.layout = html.Div(
+        [
+            html.Div("Tooltip Preview:", style={"color": "white", "marginBottom": "20px"}),
+            *molecule_hover_tooltip("CC(=O)OC1=CC=CC=C1C(=O)O", mol_id="Aspirin", background="rgba(200, 30, 30, 1)"),
+        ],
+        style={"background": "#1a1a1a", "padding": "50px"},
+    )
+
+    if __name__ == "__main__":
+        app.run(debug=True)
 
     print("\n✅ All tests completed!")

workbench/utils/clientside_callbacks.py

@@ -0,0 +1,41 @@
+"""Clientside JavaScript callbacks for Dash components.
+
+These functions return JavaScript code strings for use with Dash's clientside_callback.
+Using clientside callbacks avoids server round-trips for simple UI interactions.
+"""
+
+
+def circle_overlay_callback(circle_data_uri: str) -> str:
+    """Returns JS function for circle overlay on scatter plot hover.
+
+    Args:
+        circle_data_uri: Base64-encoded SVG data URI for the circle overlay
+
+    Returns:
+        JavaScript function string for use with clientside_callback
+    """
+    return f"""
+    function(hoverData) {{
+        if (!hoverData) {{
+            return [false, window.dash_clientside.no_update, window.dash_clientside.no_update];
+        }}
+        var bbox = hoverData.points[0].bbox;
+        var centerX = (bbox.x0 + bbox.x1) / 2;
+        var centerY = (bbox.y0 + bbox.y1) / 2;
+        var adjustedBbox = {{
+            x0: centerX - 50,
+            x1: centerX + 50,
+            y0: centerY - 162,
+            y1: centerY - 62
+        }};
+        var imgElement = {{
+            type: 'Img',
+            namespace: 'dash_html_components',
+            props: {{
+                src: '{circle_data_uri}',
+                style: {{width: '100px', height: '100px'}}
+            }}
+        }};
+        return [true, adjustedBbox, [imgElement]];
+    }}
+    """

workbench/utils/markdown_utils.py

@@ -185,6 +185,63 @@ def dict_to_collapsible_html(data: dict, title: str = None, collapse_all: bool =
     return result
 
 
+def df_to_html_table(df, round_digits: int = 2, margin_bottom: int = 30) -> str:
+    """Convert a DataFrame to a compact styled HTML table (horizontal layout).
+
+    Args:
+        df: DataFrame with metrics (can be single or multi-row)
+        round_digits: Number of decimal places to round to (default: 2)
+        margin_bottom: Bottom margin in pixels (default: 30)
+
+    Returns:
+        str: HTML table string
+    """
+    # Handle index: reset if named (keeps as column), otherwise drop
+    if df.index.name:
+        df = df.reset_index()
+    else:
+        df = df.reset_index(drop=True)
+
+    # Round numeric columns
+    df = df.round(round_digits)
+
+    # Table styles
+    container_style = f"display: flex; justify-content: center; margin-top: 10px; margin-bottom: {margin_bottom}px;"
+    table_style = "border-collapse: collapse; width: 100%; font-size: 15px;"
+    header_style = (
+        "background: linear-gradient(to bottom, #4a4a4a 0%, #2d2d2d 100%); "
+        "color: white; padding: 4px 8px; text-align: center;"
+    )
+    cell_style = "padding: 3px 8px; text-align: center; border-bottom: 1px solid #444;"
+
+    # Build the HTML table (wrapped in centered container)
+    html = f'<div style="{container_style}"><table style="{table_style}">'
+
+    # Header row
+    html += "<tr>"
+    for col in df.columns:
+        html += f'<th style="{header_style}">{col}</th>'
+    html += "</tr>"
+
+    # Data rows
+    for _, row in df.iterrows():
+        html += "<tr>"
+        for val in row:
+            # Format value: integers without decimal, floats rounded
+            if isinstance(val, float):
+                if val == int(val):
+                    formatted_val = int(val)
+                else:
+                    formatted_val = round(val, round_digits)
+            else:
+                formatted_val = val
+            html += f'<td style="{cell_style}">{formatted_val}</td>'
+        html += "</tr>"
+
+    html += "</table></div>"
+    return html
+
+
 if __name__ == "__main__":
     """Exercise the Markdown Utilities"""
     from workbench.api.model import Model

workbench/utils/model_utils.py

@@ -173,7 +173,6 @@ def fingerprint_prox_model_local(
         include_all_columns=include_all_columns,
         radius=radius,
         n_bits=n_bits,
-        counts=counts,
     )
 
 

workbench/utils/pipeline_utils.py

@@ -6,7 +6,6 @@ import json
 # Workbench Imports
 from workbench.api import DataSource, FeatureSet, Model, Endpoint, ParameterStore
 
-
 # Set up the logging
 log = logging.getLogger("workbench")
 

workbench/utils/plot_utils.py

@@ -1,14 +1,17 @@
 """Plot Utilities for Workbench"""
 
+import logging
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
 
+log = logging.getLogger("workbench")
+
 
 # For approximating beeswarm effect
 def beeswarm_offsets(values, point_size=0.05, precision=2, max_offset=0.3):
     """
-    Generate optimal beeswarm offsets with a maximum limit.
+    Generate beeswarm offsets using random jitter with collision avoidance.
 
     Args:
         values: Array of positions to be adjusted
@@ -22,42 +25,55 @@ def beeswarm_offsets(values, point_size=0.05, precision=2, max_offset=0.3):
     values = np.asarray(values)
     rounded = np.round(values, precision)
     offsets = np.zeros_like(values, dtype=float)
-
-    # Sort indices by original values
-    sorted_idx = np.argsort(values)
+    rng = np.random.default_rng(42)  # Fixed seed for reproducibility
 
     for val in np.unique(rounded):
         # Get indices belonging to this group
-        group_idx = sorted_idx[np.isin(sorted_idx, np.where(rounded == val)[0])]
+        group_mask = rounded == val
+        group_idx = np.where(group_mask)[0]
 
         if len(group_idx) > 1:
             # Track occupied positions for collision detection
             occupied = []
 
             for idx in group_idx:
-                # Find best position with no collision
-                offset = 0
-                direction = 1
-                step = 0
-
-                while True:
-                    # Check if current offset position is free
-                    collision = any(abs(offset - pos) < point_size for pos in occupied)
-
-                    if not collision or abs(offset) >= max_offset:
-                        # Accept position if no collision or max offset reached
-                        if abs(offset) > max_offset:
-                            # Clamp to maximum
-                            offset = max_offset * (1 if offset > 0 else -1)
-                        break
-
-                    # Switch sides with increasing distance
-                    step += 0.25
-                    direction *= -1
-                    offset = direction * step * point_size
-
-                offsets[idx] = offset
-                occupied.append(offset)
+                # Try random positions, starting near center and expanding outward
+                best_offset = 0
+                found = False
+
+                # First point goes to center
+                if not occupied:
+                    found = True
+                else:
+                    # Try random positions with increasing spread
+                    for attempt in range(50):
+                        # Gradually increase the range of random offsets
+                        spread = min(max_offset, point_size * (1 + attempt * 0.5))
+                        offset = rng.uniform(-spread, spread)
+
+                        # Check for collision with occupied positions
+                        if not any(abs(offset - pos) < point_size for pos in occupied):
+                            best_offset = offset
+                            found = True
+                            break
+
+                    # If no free position found after attempts, find the least crowded spot
+                    if not found:
+                        # Try a grid of positions and pick one with most space
+                        candidates = np.linspace(-max_offset, max_offset, 20)
+                        rng.shuffle(candidates)
+                        for candidate in candidates:
+                            if not any(abs(candidate - pos) < point_size * 0.8 for pos in occupied):
+                                best_offset = candidate
+                                found = True
+                                break
+
+                        # Last resort: just use a random position within bounds
+                        if not found:
+                            best_offset = rng.uniform(-max_offset, max_offset)
+
+                offsets[idx] = best_offset
+                occupied.append(best_offset)
 
     return offsets
 
@@ -126,13 +142,13 @@ def prediction_intervals(df, figure, x_col):
 
     # Sort dataframe by x_col for connected lines
     sorted_df = df.sort_values(by=x_col)
-    # Add outer band (q_025 to q_975) - more transparent
+    # Add outer band (q_025 to q_975) - desaturated blue-gray, more transparent
     figure.add_trace(
         go.Scatter(
             x=sorted_df[x_col],
             y=sorted_df["q_025"],
             mode="lines",
-            line=dict(width=1, color="rgba(99, 110, 250, 0.25)"),
+            line=dict(width=1, color="rgba(120, 130, 180, 0.3)"),
             name="2.5 Percentile",
             hoverinfo="skip",
             showlegend=False,
@@ -143,21 +159,21 @@ def prediction_intervals(df, figure, x_col):
             x=sorted_df[x_col],
             y=sorted_df["q_975"],
             mode="lines",
-            line=dict(width=1, color="rgba(99, 110, 250, 0.25)"),
+            line=dict(width=1, color="rgba(120, 130, 180, 0.3)"),
             name="97.5 Percentile",
             hoverinfo="skip",
             showlegend=False,
             fill="tonexty",
-            fillcolor="rgba(99, 110, 250, 0.2)",
+            fillcolor="rgba(120, 130, 180, 0.15)",
         )
     )
-    # Add inner band (q_25 to q_75) - less transparent
+    # Add inner band (q_25 to q_75) - desaturated green-gray, slightly more visible
     figure.add_trace(
         go.Scatter(
             x=sorted_df[x_col],
             y=sorted_df["q_25"],
             mode="lines",
-            line=dict(width=1, color="rgba(99, 250, 110, 0.25)"),
+            line=dict(width=1, color="rgba(130, 180, 140, 0.3)"),
             name="25 Percentile",
             hoverinfo="skip",
             showlegend=False,
@@ -168,12 +184,12 @@ def prediction_intervals(df, figure, x_col):
             x=sorted_df[x_col],
             y=sorted_df["q_75"],
             mode="lines",
-            line=dict(width=1, color="rgba(99, 250, 100, 0.25)"),
+            line=dict(width=1, color="rgba(130, 180, 140, 0.3)"),
             name="75 Percentile",
             hoverinfo="skip",
             showlegend=False,
             fill="tonexty",
-            fillcolor="rgba(99, 250, 110, 0.2)",
+            fillcolor="rgba(130, 180, 140, 0.18)",
         )
     )
     return figure