workbench 0.8.234__py3-none-any.whl → 0.8.236__py3-none-any.whl

workbench/themes/dark/custom.css

@@ -135,6 +135,35 @@ div:has(> [class*="ag-theme-"]) {
     --bs-border-color: rgb(60, 60, 60);
 }
 
+/* React-select dropdown styling - target actual rendered elements */
+.Select-control {
+    background-color: rgb(35, 35, 35) !important;
+    border-color: rgb(60, 60, 60) !important;
+}
+
+.Select-value-label, .Select-input input {
+    color: rgb(210, 210, 210) !important;
+}
+
+.Select-placeholder {
+    color: rgb(150, 150, 150) !important;
+}
+
+.Select-menu-outer {
+    background-color: rgb(35, 35, 35) !important;
+    border-color: rgb(60, 60, 60) !important;
+}
+
+.VirtualizedSelectOption {
+    background-color: rgb(35, 35, 35) !important;
+    color: rgb(210, 210, 210) !important;
+}
+
+.VirtualizedSelectFocusedOption {
+    background-color: rgb(60, 60, 60) !important;
+    color: rgb(230, 230, 230) !important;
+}
+
 /* Bootstrap form controls (dbc components) */
 .form-select, .form-control {
     background-color: rgb(35, 35, 35) !important;

workbench/themes/light/custom.css

@@ -180,6 +180,35 @@ div:has(> [class*="ag-theme-"]) {
     --bs-border-color: var(--wb-accent);
 }
 
+/* React-select dropdown styling - target actual rendered elements */
+.Select-control {
+    background-color: var(--wb-dropdown-bg) !important;
+    border-color: var(--wb-accent) !important;
+}
+
+.Select-value-label, .Select-input input {
+    color: var(--wb-text-primary) !important;
+}
+
+.Select-placeholder {
+    color: var(--wb-text-muted) !important;
+}
+
+.Select-menu-outer {
+    background-color: var(--wb-dropdown-bg) !important;
+    border-color: var(--wb-accent) !important;
+}
+
+.VirtualizedSelectOption {
+    background-color: var(--wb-dropdown-bg) !important;
+    color: var(--wb-text-primary) !important;
+}
+
+.VirtualizedSelectFocusedOption {
+    background-color: var(--wb-dropdown-hover) !important;
+    color: var(--wb-text-primary) !important;
+}
+
 /* Bootstrap form controls (dbc components) */
 .form-select, .form-control {
     background-color: var(--wb-dropdown-bg) !important;

workbench/themes/midnight_blue/custom.css

@@ -133,6 +133,34 @@ div:has(> [class*="ag-theme-"]) {
     --bs-border-color: rgb(80, 85, 115);
 }
 
+/* React-select dropdown styling - target actual rendered elements */
+.Select-control {
+    background-color: rgb(55, 60, 90) !important;
+    border-color: rgb(80, 85, 115) !important;
+}
+
+.Select-value-label, .Select-input input {
+    color: rgb(210, 210, 210) !important;
+}
+
+.Select-placeholder {
+    color: rgb(150, 150, 170) !important;
+}
+
+.Select-menu-outer {
+    background-color: rgb(55, 60, 90) !important;
+    border-color: rgb(80, 85, 115) !important;
+}
+
+.VirtualizedSelectOption {
+    background-color: rgb(55, 60, 90) !important;
+    color: rgb(210, 210, 210) !important;
+}
+
+.VirtualizedSelectFocusedOption {
+    background-color: rgb(70, 75, 110) !important;
+    color: rgb(230, 230, 230) !important;
+}
 
 /* Bootstrap form controls (dbc components) */
 .form-select, .form-control {

workbench/utils/model_utils.py

@@ -459,6 +459,12 @@ def uq_metrics(df: pd.DataFrame, target_col: str) -> Dict[str, Any]:
     # Spearman correlation for robustness
     interval_to_error_corr = spearmanr(width_68, abs_residuals)[0]
 
+    # --- Confidence to Error Correlation ---
+    # If confidence column exists, compute correlation (should be negative: high confidence = low error)
+    confidence_to_error_corr = None
+    if "confidence" in df.columns:
+        confidence_to_error_corr = spearmanr(df["confidence"], abs_residuals)[0]
+
     # Collect results
     results = {
         "coverage_68": coverage_68,
@@ -472,6 +478,7 @@ def uq_metrics(df: pd.DataFrame, target_col: str) -> Dict[str, Any]:
         "median_width_90": median_width_90,
         "median_width_95": median_width_95,
         "interval_to_error_corr": interval_to_error_corr,
+        "confidence_to_error_corr": confidence_to_error_corr,
         "n_samples": len(df),
     }
 
@@ -489,6 +496,8 @@ def uq_metrics(df: pd.DataFrame, target_col: str) -> Dict[str, Any]:
     print(f"CRPS: {mean_crps:.3f} (lower is better)")
     print(f"Interval Score 95%: {mean_is_95:.3f} (lower is better)")
     print(f"Interval/Error Corr: {interval_to_error_corr:.3f} (higher is better, target: >0.5)")
+    if confidence_to_error_corr is not None:
+        print(f"Confidence/Error Corr: {confidence_to_error_corr:.3f} (lower is better, target: <-0.5)")
     print(f"Samples: {len(df)}")
     return results
 

workbench/utils/theme_manager.py

@@ -155,6 +155,101 @@ class ThemeManager:
         """Get the name of the current theme."""
         return cls.current_theme_name
 
+    @classmethod
+    def get_theme_urls(cls) -> dict:
+        """Get a mapping of theme names to their Bootstrap CSS URLs."""
+        return {name: theme["base_css"] for name, theme in cls.available_themes.items() if theme["base_css"]}
+
+    @classmethod
+    def get_dark_themes(cls) -> list:
+        """Get list of theme names that are dark mode themes."""
+        dark_themes = []
+        for name, theme in cls.available_themes.items():
+            base_css = theme.get("base_css", "")
+            if base_css:
+                base_css_upper = base_css.upper()
+                for dark_theme in cls._dark_bootstrap_themes:
+                    if dark_theme in base_css_upper:
+                        dark_themes.append(name)
+                        break
+                else:
+                    # Fallback: check if 'dark' is in the theme name
+                    if "dark" in name.lower():
+                        dark_themes.append(name)
+        return dark_themes
+
+    @classmethod
+    def get_theme_switch_js(cls) -> str:
+        """Get the JavaScript code for dynamic theme switching.
+
+        This code should be used in a clientside callback that updates the Bootstrap
+        stylesheet and data-bs-theme attribute when the user selects a new theme.
+        """
+        theme_urls = cls.get_theme_urls()
+        dark_themes = cls.get_dark_themes()
+
+        return f"""
+        function(n_clicks_list, ids) {{
+            // Use callback context to find which input triggered this callback
+            const ctx = window.dash_clientside.callback_context;
+            if (!ctx || !ctx.triggered || ctx.triggered.length === 0) {{
+                return window.dash_clientside.no_update;
+            }}
+
+            // Get the triggered input's id (it's a JSON string for pattern-matching callbacks)
+            const triggeredId = ctx.triggered[0].prop_id.split('.')[0];
+            let clickedTheme = null;
+
+            try {{
+                const parsedId = JSON.parse(triggeredId);
+                clickedTheme = parsedId.theme;
+            }} catch (e) {{
+                // Not a pattern-matching callback ID
+                return window.dash_clientside.no_update;
+            }}
+
+            if (!clickedTheme) {{
+                return window.dash_clientside.no_update;
+            }}
+
+            // Store in localStorage and cookie
+            localStorage.setItem('wb_theme', clickedTheme);
+            document.cookie = `wb_theme=${{clickedTheme}}; path=/; max-age=31536000`;
+
+            // Theme URL mapping (generated from ThemeManager)
+            const themeUrls = {json.dumps(theme_urls)};
+            const darkThemes = {json.dumps(dark_themes)};
+
+            // Update Bootstrap's data-bs-theme attribute
+            const bsTheme = darkThemes.includes(clickedTheme) ? 'dark' : 'light';
+            document.documentElement.setAttribute('data-bs-theme', bsTheme);
+
+            // Find and update the Bootstrap stylesheet
+            const newUrl = themeUrls[clickedTheme];
+            if (newUrl) {{
+                let stylesheet = document.querySelector('link[href*="bootswatch"]') ||
+                                 document.querySelector('link[href*="bootstrap"]') ||
+                                 document.querySelector('link[href="/base.css"]');
+                if (stylesheet) {{
+                    stylesheet.setAttribute('href', newUrl);
+                }} else {{
+                    stylesheet = document.createElement('link');
+                    stylesheet.rel = 'stylesheet';
+                    stylesheet.href = newUrl;
+                    document.head.appendChild(stylesheet);
+                }}
+            }}
+
+            // Force reload custom.css with cache-busting query param
+            let customCss = document.querySelector('link[href^="/custom.css"]');
+            if (customCss) {{
+                customCss.setAttribute('href', `/custom.css?t=${{Date.now()}}`);
+            }}
+
+            return clickedTheme;
+        }}
+        """
+
     @classmethod
     def background(cls) -> list[list[float | str]]:
         """Get the plot background for the current theme."""

workbench/web_interface/components/component_interface.py

@@ -136,6 +136,7 @@ class ComponentInterface(ABC):
             xref="paper",
             yref="paper",
             text=text_message,
+            bgcolor="rgba(0,0,0,0)",
             showarrow=False,
             font=dict(size=font_size, color="#9999cc"),
         )
@@ -144,6 +145,8 @@ class ComponentInterface(ABC):
             xaxis=dict(showticklabels=False, zeroline=False, showgrid=False),
             yaxis=dict(showticklabels=False, zeroline=False, showgrid=False),
             margin=dict(l=0, r=0, b=0, t=0),
+            paper_bgcolor="rgba(0,0,0,0)",
+            plot_bgcolor="rgba(0,0,0,0)",
         )
 
         if figure_height is not None:

workbench/web_interface/components/plugin_interface.py

@@ -3,10 +3,12 @@ import inspect
 from typing import Union, Tuple, get_args, get_origin
 from enum import Enum
 import logging
+from dash import no_update
 from dash.development.base_component import Component
 
 # Local Imports
 from workbench.web_interface.components.component_interface import ComponentInterface
+from workbench.utils.theme_manager import ThemeManager
 
 log = logging.getLogger("workbench")
 
@@ -48,6 +50,9 @@ class PluginInterface(ComponentInterface):
         - The 'register_internal_callbacks' method is optional
     """
 
+    # Shared ThemeManager instance for all plugins
+    theme_manager = ThemeManager()
+
     @abstractmethod
     def create_component(self, component_id: str) -> Component:
         """Create a Dash Component without any data.
@@ -83,6 +88,27 @@ class PluginInterface(ComponentInterface):
         """
         pass
 
+    def set_theme(self, theme: str) -> list:
+        """Called when the application theme changes. Override to re-render with new theme colors.
+
+        The default implementation returns no_update for all properties. Plugins that have
+        theme-dependent rendering (e.g., figures with colorscales) should override this method
+        to re-render their components.
+
+        Args:
+            theme (str): The name of the new theme (e.g., "light", "dark", "midnight_blue").
+
+        Returns:
+            list: Updated property values (same format as update_properties), or no_update list.
+
+        Example:
+            def set_theme(self, theme: str) -> list:
+                if self.model is None:
+                    return [no_update] * len(self.properties)
+                return self.update_properties(self.model)
+        """
+        return [no_update] * len(self.properties)
+
     #
     # Internal Methods: These methods are used to validate the plugin interface at runtime
     #

workbench/web_interface/components/plugins/confusion_matrix.py

@@ -1,11 +1,10 @@
 """A confusion matrix plugin component"""
 
-from dash import dcc, callback, Output, Input, State
+from dash import dcc, callback, Output, Input, State, no_update
 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
 from workbench.cached.cached_model import CachedModel
 from workbench.utils.color_utils import add_alpha_to_first_color
 
@@ -19,10 +18,8 @@ class ConfusionMatrix(PluginInterface):
     def __init__(self):
         """Initialize the ConfusionMatrix plugin class"""
         self.component_id = None
-        self.current_highlight = None  # Store the currently highlighted cell
-        self.theme_manager = ThemeManager()
-
-        # Call the parent class constructor
+        self.model = None  # Store the model for re-rendering on theme change
+        self.inference_run = None  # Store the inference run for re-rendering
         super().__init__()
 
     def create_component(self, component_id: str) -> dcc.Graph:
@@ -57,9 +54,12 @@ class ConfusionMatrix(PluginInterface):
         Returns:
             list: A list containing the updated Plotly figure.
         """
+        # Store for re-rendering on theme change
+        self.model = model
+        self.inference_run = kwargs.get("inference_run", "auto_inference")
+
         # Retrieve the confusion matrix data
-        inference_run = kwargs.get("inference_run", "auto_inference")
-        df = model.confusion_matrix(inference_run)
+        df = model.confusion_matrix(self.inference_run)
         if df is None:
             return [self.display_text("No Data")]
 
@@ -137,6 +137,12 @@ class ConfusionMatrix(PluginInterface):
         # Return the updated figure wrapped in a list
         return [fig]
 
+    def set_theme(self, theme: str) -> list:
+        """Re-render the confusion matrix when the theme changes."""
+        if self.model is None:
+            return [no_update] * len(self.properties)
+        return self.update_properties(self.model, inference_run=self.inference_run)
+
     def register_internal_callbacks(self):
         """Register internal callbacks for the plugin."""
 

workbench/web_interface/components/plugins/model_plot.py

@@ -0,0 +1,156 @@
+"""A Model Plot plugin that displays the appropriate visualization based on model type.
+
+For classifiers: Shows a Confusion Matrix
+For regressors: Shows a Scatter Plot of predictions vs actuals
+"""
+
+from dash import html, no_update
+
+# Workbench Imports
+from workbench.api import ModelType
+from workbench.cached.cached_model import CachedModel
+from workbench.web_interface.components.plugin_interface import PluginInterface, PluginPage, PluginInputType
+from workbench.web_interface.components.plugins.confusion_matrix import ConfusionMatrix
+from workbench.web_interface.components.plugins.scatter_plot import ScatterPlot
+
+
+class ModelPlot(PluginInterface):
+    """Model Plot Plugin - switches between ConfusionMatrix and ScatterPlot based on model type."""
+
+    auto_load_page = PluginPage.NONE
+    plugin_input_type = PluginInputType.MODEL
+
+    def __init__(self):
+        """Initialize the ModelPlot plugin class"""
+        self.component_id = None
+        self.model = None
+        self.inference_run = None
+
+        # Internal plugins
+        self.scatter_plot = ScatterPlot()
+        self.confusion_matrix = ConfusionMatrix()
+
+        # Call the parent class constructor
+        super().__init__()
+
+    def create_component(self, component_id: str) -> html.Div:
+        """Create a container with both ScatterPlot and ConfusionMatrix components.
+
+        Args:
+            component_id (str): The ID of the web component
+
+        Returns:
+            html.Div: Container with both plot types (one hidden based on model type)
+        """
+        self.component_id = component_id
+
+        # Create internal components
+        scatter_component = self.scatter_plot.create_component(f"{component_id}-scatter")
+        confusion_component = self.confusion_matrix.create_component(f"{component_id}-confusion")
+
+        # Build properties list: visibility styles + scatter props + confusion props
+        self.properties = [
+            (f"{component_id}-scatter-container", "style"),
+            (f"{component_id}-confusion-container", "style"),
+        ]
+        self.properties.extend(self.scatter_plot.properties)
+        self.properties.extend(self.confusion_matrix.properties)
+
+        # Aggregate signals from both plugins
+        self.signals = self.scatter_plot.signals + self.confusion_matrix.signals
+
+        # Create container with both components
+        # Show scatter plot by default (will display "Waiting for Data..." until model loads)
+        return html.Div(
+            id=component_id,
+            children=[
+                html.Div(
+                    scatter_component,
+                    id=f"{component_id}-scatter-container",
+                    style={"display": "block"},
+                ),
+                html.Div(
+                    confusion_component,
+                    id=f"{component_id}-confusion-container",
+                    style={"display": "none"},
+                ),
+            ],
+        )
+
+    def update_properties(self, model: CachedModel, **kwargs) -> list:
+        """Update the plot based on model type.
+
+        Args:
+            model (CachedModel): The model to visualize
+            **kwargs:
+                - inference_run (str): Inference capture name (default: "auto_inference")
+
+        Returns:
+            list: Property values [scatter_style, confusion_style, ...scatter_props, ...confusion_props]
+        """
+        # Cache for theme re-rendering
+        self.model = model
+        self.inference_run = kwargs.get("inference_run", "full_cross_fold")
+
+        # Determine model type and set visibility
+        is_classifier = model.model_type == ModelType.CLASSIFIER
+        scatter_style = {"display": "none"} if is_classifier else {"display": "block"}
+        confusion_style = {"display": "block"} if is_classifier else {"display": "none"}
+
+        if is_classifier:
+            # Update ConfusionMatrix, no_update for ScatterPlot
+            cm_props = self.confusion_matrix.update_properties(model, inference_run=self.inference_run)
+            scatter_props = [no_update] * len(self.scatter_plot.properties)
+        else:
+            # Update ScatterPlot with regression data
+            df = model.get_inference_predictions(self.inference_run)
+            if df is None:
+                # Still update visibility styles, but no_update for plugin properties
+                scatter_props = [no_update] * len(self.scatter_plot.properties)
+                cm_props = [no_update] * len(self.confusion_matrix.properties)
+                return [scatter_style, confusion_style] + scatter_props + cm_props
+
+            # Get target column for the x-axis
+            target = model.target()
+            if isinstance(target, list):
+                target = next((t for t in target if t in self.inference_run), target[0])
+
+            # Check if "confidence" column exists for coloring
+            color_col = "confidence" if "confidence" in df.columns else "prediction"
+
+            scatter_props = self.scatter_plot.update_properties(
+                df,
+                x=target,
+                y="prediction",
+                color=color_col,
+                regression_line=True,
+            )
+            cm_props = [no_update] * len(self.confusion_matrix.properties)
+
+        return [scatter_style, confusion_style] + scatter_props + cm_props
+
+    def set_theme(self, theme: str) -> list:
+        """Re-render the appropriate plot when the theme changes."""
+        if self.model is None:
+            return [no_update] * len(self.properties)
+
+        # Just call update_properties which will re-render the right plot
+        return self.update_properties(self.model, inference_run=self.inference_run)
+
+    def register_internal_callbacks(self):
+        """Register internal callbacks for both sub-plugins."""
+        self.scatter_plot.register_internal_callbacks()
+        self.confusion_matrix.register_internal_callbacks()
+
+
+if __name__ == "__main__":
+    """Run the Unit Test for the Plugin."""
+    from workbench.web_interface.components.plugin_unit_test import PluginUnitTest
+
+    # Test with a classifier (shows Confusion Matrix)
+    classifier_model = CachedModel("wine-classification")
+    PluginUnitTest(ModelPlot, input_data=classifier_model, theme="dark").run()
+
+    # Test with a regressor (shows Scatter Plot)
+    regressor_model = CachedModel("abalone-regression")
+    PluginUnitTest(ModelPlot, input_data=regressor_model, theme="dark").run()

workbench/web_interface/components/plugins/scatter_plot.py

@@ -8,7 +8,6 @@ from dash.exceptions import PreventUpdate
 
 # Workbench Imports
 from workbench.web_interface.components.plugin_interface import PluginInterface, PluginPage, PluginInputType
-from workbench.utils.theme_manager import ThemeManager
 from workbench.utils.plot_utils import prediction_intervals
 from workbench.utils.chem_utils.vis import molecule_hover_tooltip
 from workbench.utils.clientside_callbacks import circle_overlay_callback
@@ -37,7 +36,6 @@ class ScatterPlot(PluginInterface):
         self.hover_columns = []
         self.df = None
         self.show_axes = show_axes
-        self.theme_manager = ThemeManager()
         self.has_smiles = False  # Track if dataframe has smiles column for molecule hover
         self.smiles_column = None
         self.id_column = None
@@ -242,6 +240,15 @@ class ScatterPlot(PluginInterface):
 
         return [figure, x_options, y_options, color_options, x_default, y_default, color_default, regression_line_value]
 
+    def set_theme(self, theme: str) -> list:
+        """Re-render the scatter plot when the theme changes."""
+        # If no data yet, return no_update for all properties
+        if self.df is None or self.df.empty:
+            return [no_update] * len(self.properties)
+
+        # Re-render with defaults (user dropdown selections reset, but theme changes are rare)
+        return self.update_properties(self.df)
+
     def create_scatter_plot(
         self,
         df: pd.DataFrame,

workbench/web_interface/components/plugins/shap_summary_plot.py

@@ -1,6 +1,6 @@
 """SHAP Summary Plot visualization component for XGBoost models"""
 
-from dash import dcc
+from dash import dcc, no_update
 import plotly.graph_objects as go
 import pandas as pd
 import numpy as np
@@ -9,7 +9,6 @@ from typing import Dict, List
 # Workbench Imports
 from workbench.cached.cached_model import CachedModel
 from workbench.web_interface.components.plugin_interface import PluginInterface, PluginPage, PluginInputType
-from workbench.utils.theme_manager import ThemeManager
 from workbench.utils.plot_utils import beeswarm_offsets
 
 
@@ -22,7 +21,7 @@ class ShapSummaryPlot(PluginInterface):
     def __init__(self):
         """Initialize the ShapSummaryPlot plugin class"""
         self.component_id = None
-        self.theme_manager = ThemeManager()
+        self.model = None  # Store the model for re-rendering on theme change
         super().__init__()
 
     def create_component(self, component_id: str) -> dcc.Graph:
@@ -39,6 +38,9 @@ class ShapSummaryPlot(PluginInterface):
 
     def update_properties(self, model: CachedModel, **kwargs) -> list:
         """Create a SHAP Summary Plot for feature importance visualization."""
+        # Store for re-rendering on theme change
+        self.model = model
+
         # Basic validation
         shap_data = model.shap_data()
         shap_sample_rows = model.shap_sample()
@@ -221,9 +223,15 @@ class ShapSummaryPlot(PluginInterface):
         )
         return main_fig
 
+    def set_theme(self, theme: str) -> list:
+        """Re-render the SHAP summary plot when the theme changes."""
+        if self.model is None:
+            return [no_update] * len(self.properties)
+        return self.update_properties(self.model)
+
     def register_internal_callbacks(self):
         """Register internal callbacks for the plugin."""
-        pass  # Implement if needed
+        pass  # No internal callbacks needed
 
 
 if __name__ == "__main__":