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

workbench/utils/chem_utils/projections.py

@@ -17,18 +17,28 @@ log = logging.getLogger("workbench")
 
 def fingerprints_to_matrix(fingerprints, dtype=np.uint8):
     """
-    Convert bitstring fingerprints to numpy matrix.
+    Convert fingerprints to numpy matrix.
+
+    Supports two formats (auto-detected):
+        - Bitstrings: "10110010..." → matrix of 0s and 1s
+        - Count vectors: "0,3,0,1,5,..." → matrix of counts (or binary if dtype=np.bool_)
 
     Args:
-        fingerprints: pandas Series or list of bitstring fingerprints
-        dtype: numpy data type (uint8 is default: np.bool_ is good for Jaccard computations
+        fingerprints: pandas Series or list of fingerprints
+        dtype: numpy data type (uint8 is default; np.bool_ for Jaccard computations)
 
     Returns:
         dense numpy array of shape (n_molecules, n_bits)
     """
-
-    # Dense matrix representation (we might support sparse in the future)
-    return np.array([list(fp) for fp in fingerprints], dtype=dtype)
+    # Auto-detect format based on first fingerprint
+    sample = str(fingerprints.iloc[0] if hasattr(fingerprints, "iloc") else fingerprints[0])
+    if "," in sample:
+        # Count vector format: comma-separated integers
+        matrix = np.array([list(map(int, fp.split(","))) for fp in fingerprints], dtype=dtype)
+    else:
+        # Bitstring format: each character is a bit
+        matrix = np.array([list(fp) for fp in fingerprints], dtype=dtype)
+    return matrix
 
 
 def project_fingerprints(df: pd.DataFrame, projection: str = "UMAP") -> pd.DataFrame:

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

@@ -1,14 +1,18 @@
 """Plot Utilities for Workbench"""
 
+import logging
 import numpy as np
 import pandas as pd
 import plotly.graph_objects as go
+from dash import html
+
+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 +26,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
 
@@ -179,6 +196,107 @@ def prediction_intervals(df, figure, x_col):
     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/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}'...")