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

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/ag_table.py

@@ -96,18 +96,11 @@ class AGTable(PluginInterface):
 
 if __name__ == "__main__":
     # Run the Unit Test for the Plugin
+    from workbench.api import Meta
     from workbench.web_interface.components.plugin_unit_test import PluginUnitTest
 
-    # Test data
-    data = {
-        "ID": [f"id_{i}" for i in range(10)],
-        "feat1": [1.0, 1.0, 1.1, 3.0, 4.0, 1.0, 1.0, 1.1, 3.0, 4.0],
-        "feat2": [1.0, 1.0, 1.1, 3.0, 4.0, 1.0, 1.0, 1.1, 3.0, 4.0],
-        "feat3": [0.1, 0.15, 0.2, 0.9, 2.8, 0.25, 0.35, 0.4, 1.6, 2.5],
-        "price": [31, 60, 62, 40, 20, 31, 61, 60, 40, 20],
-        "name": ["A", "B", "C", "D", "E", "F", "G", "H", "I", "Z" * 55],
-    }
-    test_df = pd.DataFrame(data)
+    # Test on model data
+    models_df = Meta().models(details=True)
 
     # Run the Unit Test on the Plugin
-    PluginUnitTest(AGTable, theme="dark", input_data=test_df, max_height=500).run()
+    PluginUnitTest(AGTable, theme="dark", input_data=models_df, max_height=500).run()

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__":

workbench/web_interface/components/settings_menu.py

@@ -100,74 +100,35 @@ class SettingsMenu:
                     caret=False,
                     align_end=True,
                 ),
-                # Dummy store for the clientside callback output
-                dcc.Store(id=f"{component_id}-dummy", data=None),
-                # Store to trigger checkmark update on load
+                # Store to trigger checkmark update on load and theme change
                 dcc.Store(id=f"{component_id}-init", data=True),
             ],
             id=component_id,
         )
 
-    @staticmethod
-    def get_clientside_callback_code(component_id: str) -> str:
+    def get_clientside_callback_code(self) -> str:
         """Get the JavaScript code for the theme selection clientside callback.
 
-        Args:
-            component_id (str): The ID prefix used in create_component.
-
         Returns:
             str: JavaScript code for the clientside callback.
         """
-        return """
-        function(n_clicks_list, ids) {
-            // Find which button was clicked
-            if (!n_clicks_list || n_clicks_list.every(n => !n)) {
-                return window.dash_clientside.no_update;
-            }
-
-            // Find the clicked theme
-            let clickedTheme = null;
-            for (let i = 0; i < n_clicks_list.length; i++) {
-                if (n_clicks_list[i]) {
-                    clickedTheme = ids[i].theme;
-                    break;
-                }
-            }
-
-            if (clickedTheme) {
-                // Store in localStorage
-                localStorage.setItem('wb_theme', clickedTheme);
-                // Set cookie for Flask to read on reload
-                document.cookie = `wb_theme=${clickedTheme}; path=/; max-age=31536000`;
-                // Reload the page to apply the new theme
-                window.location.reload();
-            }
-
-            return window.dash_clientside.no_update;
-        }
-        """
+        return self.tm.get_theme_switch_js()
 
     @staticmethod
     def get_checkmark_callback_code() -> str:
-        """Get the JavaScript code to update checkmarks based on localStorage.
+        """Get the JavaScript code to update checkmarks based on current theme.
 
         Returns:
             str: JavaScript code for the checkmark update callback.
         """
         return """
-        function(init, ids) {
-            // Get current theme from localStorage (or cookie as fallback)
-            let currentTheme = localStorage.getItem('wb_theme');
+        function(theme, ids) {
+            // If theme is a string (from theme switch), use it directly
+            let currentTheme = (typeof theme === 'string') ? theme : null;
+
+            // Otherwise, get from localStorage
             if (!currentTheme) {
-                // Try to read from cookie
-                const cookies = document.cookie.split(';');
-                for (let cookie of cookies) {
-                    const [name, value] = cookie.trim().split('=');
-                    if (name === 'wb_theme') {
-                        currentTheme = value;
-                        break;
-                    }
-                }
+                currentTheme = localStorage.getItem('wb_theme');
             }
 
             // Return checkmarks for each theme

{workbench-0.8.234.dist-info → workbench-0.8.239.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: workbench
-Version: 0.8.234
+Version: 0.8.239
 Summary: Workbench: A Dashboard and Python API for creating and deploying AWS SageMaker Model Pipelines
 Author-email: SuperCowPowers LLC <support@supercowpowers.com>
 License: MIT License
@@ -40,7 +40,7 @@ Requires-Dist: boto3>=1.31.76
 Requires-Dist: botocore>=1.31.76
 Requires-Dist: redis>=5.0.1
 Requires-Dist: numpy>=1.26.4
-Requires-Dist: pandas>=2.2.1
+Requires-Dist: pandas<3.0,>=2.2.1
 Requires-Dist: awswrangler>=3.4.0
 Requires-Dist: sagemaker<3.0,>=2.143
 Requires-Dist: cryptography>=44.0.2