workbench 0.8.224__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/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

@@ -4,7 +4,6 @@ import logging
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
-from dash import html
 
 log = logging.getLogger("workbench")
 
@@ -143,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,
@@ -160,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,
@@ -185,118 +184,17 @@ 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
 
 
-def molecule_hover_tooltip(smiles: str, mol_id: str = None, width: int = 300, height: int = 200) -> 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:
-        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)
-
-    Returns:
-        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
-    """
-    try:
-        from workbench.utils.chem_utils.vis import svg_from_smiles
-        from workbench.utils.theme_manager import ThemeManager
-
-        # Get the background color from the current theme
-        background = ThemeManager().background()
-
-        # Generate the SVG image from SMILES
-        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:
-            children.append(
-                html.Div(
-                    str(mol_id),
-                    style={
-                        "textAlign": "center",
-                        "padding": "8px",
-                        "color": "rgb(200, 200, 200)",
-                        "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",
-                },
-            )
-        ]
-
-
 if __name__ == "__main__":
     """Exercise the Plot Utilities"""
     import plotly.express as px

workbench/web_interface/components/experiments/outlier_plot.py

@@ -11,7 +11,6 @@ import logging
 from workbench.algorithms.dataframe.aggregation import aggregate
 from workbench.algorithms.dataframe.projection_2d import Projection2D
 
-
 # Workbench Logger
 log = logging.getLogger("workbench")
 

workbench/web_interface/components/model_plot.py

@@ -10,8 +10,10 @@ from workbench.api import Model, ModelType
 from workbench.web_interface.components.component_interface import ComponentInterface
 from workbench.web_interface.components.plugins.confusion_matrix import ConfusionMatrix
 from workbench.web_interface.components.plugins.scatter_plot import ScatterPlot
+from workbench.utils.deprecated_utils import deprecated
 
 
+@deprecated(version="0.9")
 class ModelPlot(ComponentInterface):
     """Model Metrics Components"""
 

workbench/web_interface/components/plugin_unit_test.py

@@ -3,7 +3,6 @@ import dash_bootstrap_components as dbc
 import logging
 import socket
 
-
 # Workbench Imports
 from workbench.web_interface.components.plugin_interface import PluginInterface, PluginInputType
 from workbench.api import DataSource, FeatureSet, Model, Endpoint, Meta

workbench/web_interface/components/plugins/ag_table.py

@@ -22,9 +22,7 @@ class AGTable(PluginInterface):
     header_height = 30
     row_height = 25
 
-    def create_component(
-        self, component_id: str, header_color: str = "rgb(120, 60, 60)", max_height: int = 500
-    ) -> AgGrid:
+    def create_component(self, component_id: str, max_height: int = 500) -> AgGrid:
         """Create a Table Component without any data."""
         self.component_id = component_id
         self.max_height = max_height
@@ -112,4 +110,4 @@ if __name__ == "__main__":
     test_df = pd.DataFrame(data)
 
     # Run the Unit Test on the Plugin
-    PluginUnitTest(AGTable, theme="quartz", input_data=test_df, max_height=500).run()
+    PluginUnitTest(AGTable, theme="dark", input_data=test_df, max_height=500).run()

workbench/web_interface/components/plugins/confusion_matrix.py

@@ -3,7 +3,6 @@
 from dash import dcc, callback, Output, Input, State
 import plotly.graph_objects as go
 
-
 # Workbench Imports
 from workbench.web_interface.components.plugin_interface import PluginInterface, PluginPage, PluginInputType
 from workbench.utils.theme_manager import ThemeManager
@@ -22,7 +21,6 @@ class ConfusionMatrix(PluginInterface):
         self.component_id = None
         self.current_highlight = None  # Store the currently highlighted cell
         self.theme_manager = ThemeManager()
-        self.colorscale = add_alpha_to_first_color(self.theme_manager.colorscale("heatmap"))
 
         # Call the parent class constructor
         super().__init__()
@@ -65,9 +63,8 @@ class ConfusionMatrix(PluginInterface):
         if df is None:
             return [self.display_text("No Data")]
 
-        # Use Plotly's default theme-friendly colorscale
-        # from plotly.colors import sequential
-        # color_scale = sequential.Plasma
+        # Get the colorscale from the current theme
+        colorscale = add_alpha_to_first_color(self.theme_manager.colorscale("heatmap"))
 
         # The confusion matrix is displayed in reverse order (flip the dataframe for correct orientation)
         df = df.iloc[::-1]
@@ -89,7 +86,7 @@ class ConfusionMatrix(PluginInterface):
                     title="Count",
                     outlinewidth=1,
                 ),
-                colorscale=self.colorscale,
+                colorscale=colorscale,
             )
         )
 

workbench/web_interface/components/plugins/model_details.py

@@ -8,9 +8,14 @@ from dash import html, callback, dcc, Input, Output, State
 # Workbench Imports
 from workbench.api import ModelType, ParameterStore
 from workbench.cached.cached_model import CachedModel
-from workbench.utils.markdown_utils import health_tag_markdown
+from workbench.utils.markdown_utils import (
+    health_tag_markdown,
+    tags_to_markdown,
+    dict_to_markdown,
+    dict_to_collapsible_html,
+    df_to_html_table,
+)
 from workbench.web_interface.components.plugin_interface import PluginInterface, PluginPage, PluginInputType
-from workbench.utils.markdown_utils import tags_to_markdown, dict_to_markdown, dict_to_collapsible_html
 
 
 class ModelDetails(PluginInterface):
@@ -44,7 +49,7 @@ class ModelDetails(PluginInterface):
                 dcc.Markdown(id=f"{self.component_id}-summary", dangerously_allow_html=True),
                 html.H5(children="Inference Metrics", style={"marginTop": "20px"}),
                 dcc.Dropdown(id=f"{self.component_id}-dropdown", className="dropdown"),
-                dcc.Markdown(id=f"{self.component_id}-metrics"),
+                dcc.Markdown(id=f"{self.component_id}-metrics", dangerously_allow_html=True),
             ],
         )
 
@@ -175,15 +180,14 @@ class ModelDetails(PluginInterface):
             markdown += "  \nNo Data  \n"
         else:
             markdown += "  \n"
-            metrics = metrics.round(3)
 
             # If the model is a classification model, have the index sorting match the class labels
             if self.current_model.model_type == ModelType.CLASSIFIER:
-                # Sort the metrics by the class labels (if they match)
                 class_labels = self.current_model.class_labels()
                 if set(metrics.index) == set(class_labels):
                     metrics = metrics.reindex(class_labels)
-            markdown += metrics.to_markdown()
+
+            markdown += df_to_html_table(metrics)
 
         # Get additional inference metrics if they exist
         model_name = self.current_model.name