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

workbench/utils/theme_manager.py

@@ -76,10 +76,28 @@ class ThemeManager:
     def set_theme(cls, theme_name: str):
         """Set the current theme."""
 
-        # For 'auto', we try to grab a theme from the Parameter Store
-        # if we can't find one, we'll set the theme to the default
+        # For 'auto', we check multiple sources in priority order:
+        # 1. Browser cookie (from localStorage, for per-user preference)
+        # 2. Parameter Store (for org-wide default)
+        # 3. Default theme
         if theme_name == "auto":
-            theme_name = cls.ps.get("/workbench/dashboard/theme", warn=False) or cls.default_theme
+            theme_name = None
+
+            # 1. Check Flask request cookie (set from localStorage)
+            try:
+                from flask import request, has_request_context
+
+                if has_request_context():
+                    theme_name = request.cookies.get("wb_theme")
+            except Exception:
+                pass
+
+            # 2. Fall back to ParameterStore
+            if not theme_name:
+                theme_name = cls.ps.get("/workbench/dashboard/theme", warn=False)
+
+            # 3. Fall back to default
+            theme_name = theme_name or cls.default_theme
 
         # Check if the theme is in our available themes
         if theme_name not in cls.available_themes:
@@ -104,9 +122,27 @@ class ThemeManager:
         cls.current_theme_name = theme_name
         cls.log.info(f"Theme set to '{theme_name}'")
 
+    # Bootstrap themes that are dark mode (from Bootswatch)
+    _dark_bootstrap_themes = {"DARKLY", "CYBORG", "SLATE", "SOLAR", "SUPERHERO", "VAPOR"}
+
     @classmethod
     def dark_mode(cls) -> bool:
-        """Check if the current theme is a dark mode theme."""
+        """Check if the current theme is a dark mode theme.
+
+        Determines dark mode by checking if the Bootstrap base theme is a known dark theme.
+        Falls back to checking if 'dark' is in the theme name.
+        """
+        theme = cls.available_themes.get(cls.current_theme_name, {})
+        base_css = theme.get("base_css", "")
+
+        # Check if the base CSS URL contains a known dark Bootstrap theme
+        if base_css:
+            base_css_upper = base_css.upper()
+            for dark_theme in cls._dark_bootstrap_themes:
+                if dark_theme in base_css_upper:
+                    return True
+
+        # Fallback: check if 'dark' is in the theme name
         return "dark" in cls.current_theme().lower()
 
     @classmethod
@@ -184,30 +220,57 @@ class ThemeManager:
 
     @classmethod
     def css_files(cls) -> list[str]:
-        """Get the list of CSS files for the current theme."""
-        theme = cls.available_themes[cls.current_theme_name]
+        """Get the list of CSS files for the current theme.
+
+        Note: Uses /base.css route for dynamic theme switching instead of CDN URLs.
+        """
         css_files = []
 
-        # Add base.css or its CDN URL
-        if theme["base_css"]:
-            css_files.append(theme["base_css"])
+        # Use Flask route for base CSS (allows dynamic theme switching)
+        css_files.append("/base.css")
 
         # Add the DBC template CSS
         css_files.append(cls.dbc_css)
 
         # Add custom.css if it exists
-        if theme["custom_css"]:
-            css_files.append("/custom.css")
+        css_files.append("/custom.css")
 
         return css_files
 
+    @classmethod
+    def _get_theme_from_cookie(cls):
+        """Get the theme dict based on the wb_theme cookie, falling back to current theme."""
+        from flask import request
+
+        theme_name = request.cookies.get("wb_theme")
+        if theme_name and theme_name in cls.available_themes:
+            return cls.available_themes[theme_name], theme_name
+        return cls.available_themes[cls.current_theme_name], cls.current_theme_name
+
     @classmethod
     def register_css_route(cls, app):
-        """Register Flask route for custom.css."""
+        """Register Flask routes for CSS and before_request hook for theme switching."""
+        from flask import redirect
+
+        @app.server.before_request
+        def check_theme_cookie():
+            """Check for theme cookie on each request and update theme if needed."""
+            _, theme_name = cls._get_theme_from_cookie()
+            if theme_name != cls.current_theme_name:
+                cls.set_theme(theme_name)
+
+        @app.server.route("/base.css")
+        def serve_base_css():
+            """Redirect to the appropriate Bootstrap theme CSS based on cookie."""
+            theme, _ = cls._get_theme_from_cookie()
+            if theme["base_css"]:
+                return redirect(theme["base_css"])
+            return "", 404
 
         @app.server.route("/custom.css")
         def serve_custom_css():
-            theme = cls.available_themes[cls.current_theme_name]
+            """Serve the custom.css file based on cookie."""
+            theme, _ = cls._get_theme_from_cookie()
             if theme["custom_css"]:
                 return send_from_directory(theme["custom_css"].parent, theme["custom_css"].name)
             return "", 404
@@ -250,23 +313,25 @@ class ThemeManager:
         # Loop over each path in the theme path
         for theme_path in cls.theme_path_list:
             for theme_dir in theme_path.iterdir():
-                if theme_dir.is_dir():
-                    theme_name = theme_dir.name
-
-                    # Grab the base.css URL
-                    base_css_url = cls._get_base_css_url(theme_dir)
-
-                    # Grab the plotly template json, custom.css, and branding json
-                    plotly_template = theme_dir / "plotly.json"
-                    custom_css = theme_dir / "custom.css"
-                    branding = theme_dir / "branding.json"
-
-                    cls.available_themes[theme_name] = {
-                        "base_css": base_css_url,
-                        "plotly_template": plotly_template,
-                        "custom_css": custom_css if custom_css.exists() else None,
-                        "branding": branding if branding.exists() else None,
-                    }
+                # Skip hidden directories (e.g., .idea, .git)
+                if not theme_dir.is_dir() or theme_dir.name.startswith("."):
+                    continue
+                theme_name = theme_dir.name
+
+                # Grab the base.css URL
+                base_css_url = cls._get_base_css_url(theme_dir)
+
+                # Grab the plotly template json, custom.css, and branding json
+                plotly_template = theme_dir / "plotly.json"
+                custom_css = theme_dir / "custom.css"
+                branding = theme_dir / "branding.json"
+
+                cls.available_themes[theme_name] = {
+                    "base_css": base_css_url,
+                    "plotly_template": plotly_template,
+                    "custom_css": custom_css if custom_css.exists() else None,
+                    "branding": branding if branding.exists() else None,
+                }
 
         if not cls.available_themes:
             cls.log.warning(f"No themes found in '{cls.theme_path_list}'...")

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