workbench 0.8.177__py3-none-any.whl → 0.8.227__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/chem_utils/vis.py

@@ -2,34 +2,18 @@
 
 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
 
+# 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.
-
-    Args:
-        color: Color in rgba(...) format
-
-    Returns:
-        True if the color is dark, False otherwise
-    """
-    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
-
-    r, g, b = map(int, match.groups())
-    return (r + g + b) / 3 < 128
-
-
 def _rgba_to_tuple(rgba: str) -> Tuple[float, float, float, float]:
     """Convert rgba string to normalized tuple (R, G, B, A).
 
@@ -75,7 +59,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 +127,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 +212,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,12 +220,20 @@ 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 "✗"

workbench/utils/chemprop_utils.py

@@ -0,0 +1,141 @@
+"""ChemProp utilities for Workbench models."""
+
+import logging
+import os
+from typing import Any, Tuple
+
+import pandas as pd
+
+from workbench.utils.aws_utils import pull_s3_data
+from workbench.utils.metrics_utils import compute_metrics_from_predictions
+from workbench.utils.model_utils import safe_extract_tarfile
+
+log = logging.getLogger("workbench")
+
+
+def download_and_extract_model(s3_uri: str, model_dir: str) -> None:
+    """Download model artifact from S3 and extract it.
+
+    Args:
+        s3_uri: S3 URI to the model artifact (model.tar.gz)
+        model_dir: Directory to extract model artifacts to
+    """
+    import awswrangler as wr
+
+    log.info(f"Downloading model from {s3_uri}...")
+
+    # Download to temp file
+    local_tar_path = os.path.join(model_dir, "model.tar.gz")
+    wr.s3.download(path=s3_uri, local_file=local_tar_path)
+
+    # Extract using safe extraction
+    log.info(f"Extracting to {model_dir}...")
+    safe_extract_tarfile(local_tar_path, model_dir)
+
+    # Cleanup tar file
+    os.unlink(local_tar_path)
+
+
+def load_chemprop_model_artifacts(model_dir: str) -> Tuple[Any, dict]:
+    """Load ChemProp MPNN model and artifacts from an extracted model directory.
+
+    Args:
+        model_dir: Directory containing extracted model artifacts
+
+    Returns:
+        Tuple of (MPNN model, artifacts_dict).
+        artifacts_dict contains 'label_encoder' and 'feature_metadata' if present.
+    """
+    import joblib
+    from chemprop import models
+
+    model_path = os.path.join(model_dir, "chemprop_model.pt")
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"No chemprop_model.pt found in {model_dir}")
+
+    model = models.MPNN.load_from_file(model_path)
+    model.eval()
+
+    # Load additional artifacts
+    artifacts = {}
+
+    label_encoder_path = os.path.join(model_dir, "label_encoder.joblib")
+    if os.path.exists(label_encoder_path):
+        artifacts["label_encoder"] = joblib.load(label_encoder_path)
+
+    feature_metadata_path = os.path.join(model_dir, "feature_metadata.joblib")
+    if os.path.exists(feature_metadata_path):
+        artifacts["feature_metadata"] = joblib.load(feature_metadata_path)
+
+    return model, artifacts
+
+
+def pull_cv_results(workbench_model: Any) -> Tuple[pd.DataFrame, pd.DataFrame]:
+    """Pull cross-validation results from AWS training artifacts.
+
+    This retrieves the validation predictions saved during model training and
+    computes metrics directly from them.
+
+    Note:
+        - Regression: Supports both single-target and multi-target models
+        - Classification: Only single-target is supported (with any number of classes)
+
+    Args:
+        workbench_model: Workbench model object
+
+    Returns:
+        Tuple of:
+            - DataFrame with computed metrics
+            - DataFrame with validation predictions
+    """
+
+    # Get the validation predictions from S3
+    s3_path = f"{workbench_model.model_training_path}/validation_predictions.csv"
+    predictions_df = pull_s3_data(s3_path)
+
+    if predictions_df is None:
+        raise ValueError(f"No validation predictions found at {s3_path}")
+
+    log.info(f"Pulled {len(predictions_df)} validation predictions from {s3_path}")
+
+    # Get target and class labels
+    target = workbench_model.target()
+    class_labels = workbench_model.class_labels()
+
+    # If single target just use the "prediction" column
+    if isinstance(target, str):
+        metrics_df = compute_metrics_from_predictions(predictions_df, target, class_labels)
+        return metrics_df, predictions_df
+
+    # Multi-target regression
+    metrics_list = []
+    for t in target:
+        # Prediction will be {target}_pred in multi-target case
+        pred_col = f"{t}_pred"
+
+        # Drop NaNs for this target
+        target_preds_df = predictions_df.dropna(subset=[t, pred_col])
+        metrics_df = compute_metrics_from_predictions(target_preds_df, t, class_labels, prediction_col=pred_col)
+        metrics_df.insert(0, "target", t)
+        metrics_list.append(metrics_df)
+    metrics_df = pd.concat(metrics_list, ignore_index=True) if metrics_list else pd.DataFrame()
+
+    return metrics_df, predictions_df
+
+
+if __name__ == "__main__":
+
+    # Tests for the ChemProp utilities
+    from workbench.api import Model
+
+    # Initialize Workbench model
+    model_name = "open-admet-chemprop-mt"
+    print(f"Loading Workbench model: {model_name}")
+    model = Model(model_name)
+    print(f"Model Framework: {model.model_framework}")
+
+    # Pull CV results
+    metrics_df, predictions_df = pull_cv_results(model)
+    print("\nTraining Metrics:")
+    print(metrics_df.to_string(index=False))
+    print(f"\nSample Predictions:\n{predictions_df.head().to_string(index=False)}")

workbench/utils/config_manager.py

@@ -4,16 +4,13 @@ import os
 import sys
 import platform
 import logging
-import importlib.resources as resources  # noqa: F401 Python 3.9 compatibility
 from typing import Any, Dict
+from importlib.resources import files, as_file
 
 # Workbench imports
 from workbench.utils.license_manager import LicenseManager
 from workbench_bridges.utils.execution_environment import running_as_service
 
-# Python 3.9 compatibility
-from workbench.utils.resource_utils import get_resource_path
-
 
 class FatalConfigError(Exception):
     """Exception raised for errors in the configuration."""
@@ -172,8 +169,7 @@ class ConfigManager:
         Returns:
             str: The open source API key.
         """
-        # Python 3.9 compatibility
-        with get_resource_path("workbench.resources", "open_source_api.key") as open_source_key_path:
+        with as_file(files("workbench.resources").joinpath("open_source_api.key")) as open_source_key_path:
             with open(open_source_key_path, "r") as key_file:
                 return key_file.read().strip()
 

workbench/utils/endpoint_utils.py

@@ -7,9 +7,7 @@ from typing import Union, Optional
 import pandas as pd
 
 # Workbench Imports
-from workbench.api.feature_set import FeatureSet
-from workbench.api.model import Model
-from workbench.api.endpoint import Endpoint
+from workbench.api import FeatureSet, Model, Endpoint
 
 # Set up the log
 log = logging.getLogger("workbench")
@@ -77,7 +75,7 @@ def internal_model_data_url(endpoint_config_name: str, session: boto3.Session) -
         return None
 
 
-def fs_training_data(end: Endpoint) -> pd.DataFrame:
+def get_training_data(end: Endpoint) -> pd.DataFrame:
     """Code to get the training data from the FeatureSet used to train the Model
 
     Args:
@@ -100,7 +98,7 @@ def fs_training_data(end: Endpoint) -> pd.DataFrame:
     return train_df
 
 
-def fs_evaluation_data(end: Endpoint) -> pd.DataFrame:
+def get_evaluation_data(end: Endpoint) -> pd.DataFrame:
     """Code to get the evaluation data from the FeatureSet NOT used for training
 
     Args:
@@ -178,11 +176,11 @@ if __name__ == "__main__":
     print(model_data_url)
 
     # Get the training data
-    my_train_df = fs_training_data(my_endpoint)
+    my_train_df = get_training_data(my_endpoint)
     print(my_train_df)
 
     # Get the evaluation data
-    my_eval_df = fs_evaluation_data(my_endpoint)
+    my_eval_df = get_evaluation_data(my_endpoint)
     print(my_eval_df)
 
     # Backtrack to the FeatureSet

workbench/utils/license_manager.py

@@ -6,15 +6,12 @@ import json
 import logging
 import requests
 from typing import Union
-import importlib.resources as resources  # noqa: F401 Python 3.9 compatibility
 from datetime import datetime
 from cryptography.hazmat.primitives import hashes
 from cryptography.hazmat.primitives.asymmetric import padding
 from cryptography.hazmat.primitives import serialization
 from cryptography.hazmat.backends import default_backend
-
-# Python 3.9 compatibility
-from workbench.utils.resource_utils import get_resource_path
+from importlib.resources import files, as_file
 
 
 class FatalLicenseError(Exception):
@@ -140,8 +137,7 @@ class LicenseManager:
         Returns:
             The public key as an object.
         """
-        # Python 3.9 compatibility
-        with get_resource_path("workbench.resources", "signature_verify_pub.pem") as public_key_path:
+        with as_file(files("workbench.resources").joinpath("signature_verify_pub.pem")) as public_key_path:
             with open(public_key_path, "rb") as key_file:
                 public_key_data = key_file.read()
 

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