polynet 1.0.2__tar.gz → 1.0.3__tar.gz

{polynet-1.0.2 → polynet-1.0.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polynet
-Version: 1.0.2
+Version: 1.0.3
 Summary: A Python package for polymer informatics: property prediction with graph neural networks and traditional machine learning
 License-Expression: MIT
 License-File: LICENSE
@@ -30,7 +30,8 @@ Requires-Dist: shap (>=0.51.0,<0.52.0)
 Requires-Dist: statsmodels (>=0.14.5,<0.15.0)
 Requires-Dist: streamlit (>=1.45.1,<2.0.0)
 Requires-Dist: torch (==2.2.0) ; sys_platform == "darwin" and platform_machine == "x86_64"
-Requires-Dist: torch (>=2.5.1,<3.0.0) ; sys_platform != "darwin" or platform_machine != "x86_64"
+Requires-Dist: torch (>=2.5.1,<2.11) ; sys_platform == "darwin" and platform_machine == "arm64"
+Requires-Dist: torch (>=2.5.1,<3.0.0) ; sys_platform != "darwin"
 Requires-Dist: torch-geometric (==2.7)
 Requires-Dist: xgboost (>=3.0.2,<4.0.0)
 Project-URL: Changelog, https://github.com/Biomaterials-for-Medical-Devices-AI/PolyNet/blob/main/CHANGELOG.md
@@ -129,6 +130,9 @@ Then install PolyNet:
 pip install polynet
 ```
 
+On macOS, XGBoost also needs the OpenMP library from [Homebrew](https://brew.sh):
+`brew install libomp`.
+
 This installs the `polynet` command: `polynet` opens the GUI and `polynet run --config
 experiment.yaml` runs the pipeline (see Quick Start below).
 
@@ -324,7 +328,7 @@ If you use PolyNet, please cite the software (GitHub's "Cite this repository" bu
 @software{polynet,
   author  = {Aguilar-Bejarano, Eduardo and Alexander, Morgan and Winkler, David and Figueredo, Grazziela},
   title   = {PolyNet: A Python Package for Polymer Informatics},
-  version = {1.0.2},
+  version = {1.0.3},
   year    = {2026},
   doi     = {10.5281/zenodo.23302984},
   url     = {https://github.com/Biomaterials-for-Medical-Devices-AI/PolyNet}

{polynet-1.0.2 → polynet-1.0.3}/README.md

@@ -89,6 +89,9 @@ Then install PolyNet:
 pip install polynet
 ```
 
+On macOS, XGBoost also needs the OpenMP library from [Homebrew](https://brew.sh):
+`brew install libomp`.
+
 This installs the `polynet` command: `polynet` opens the GUI and `polynet run --config
 experiment.yaml` runs the pipeline (see Quick Start below).
 
@@ -284,7 +287,7 @@ If you use PolyNet, please cite the software (GitHub's "Cite this repository" bu
 @software{polynet,
   author  = {Aguilar-Bejarano, Eduardo and Alexander, Morgan and Winkler, David and Figueredo, Grazziela},
   title   = {PolyNet: A Python Package for Polymer Informatics},
-  version = {1.0.2},
+  version = {1.0.3},
   year    = {2026},
   doi     = {10.5281/zenodo.23302984},
   url     = {https://github.com/Biomaterials-for-Medical-Devices-AI/PolyNet}

{polynet-1.0.2 → polynet-1.0.3}/polynet/app/components/forms/explain_model.py

@@ -5,6 +5,7 @@ from rdkit.Chem import Descriptors
 import streamlit as st
 from torch_geometric.data import Dataset
 
+from polynet.app.components.select_all import multiselect_with_select_all
 from polynet.app.options.state_keys import ExplainModelStateKeys, ProjectionPlotStateKeys
 from polynet.app.services.explain_model import (
     analyse_graph_embeddings,
@@ -252,14 +253,12 @@ def _shared_params_section(
     all_archs = sorted({_parse_gnn_filename(f)[0] for f in gnn_models})
     all_iterations = sorted({_parse_gnn_filename(f)[1] for f in gnn_models})
 
-    select_all = st.toggle(
-        "Select all GNN models", key=ExplainModelStateKeys.SelectAllModels, value=False
-    )
-    selected_archs = st.multiselect(
+    selected_archs = multiselect_with_select_all(
         "Select GNN architectures to explain",
         options=all_archs,
-        default=all_archs if select_all else None,
         key=ExplainModelStateKeys.GNNArchSelector,
+        select_all_label="Select all GNN models",
+        select_all_key=ExplainModelStateKeys.SelectAllModels,
     )
     selected_iterations = st.multiselect(
         "Select bootstrap iterations",

{polynet-1.0.2 → polynet-1.0.3}/polynet/app/components/forms/explain_tml.py

@@ -16,6 +16,7 @@ import pandas as pd
 import streamlit as st
 
 from polynet.app.components.forms.explain_model import explain_mols_widget
+from polynet.app.components.select_all import multiselect_with_select_all
 from polynet.app.options.state_keys import TMLExplainStateKeys
 from polynet.app.services.explain_tml import explain_tml_global, explain_tml_local
 from polynet.app.services.reruns import explanation_rerun_button
@@ -58,14 +59,12 @@ def _tml_shared_params_section(
     )
     all_iterations = sorted({int(key.rsplit("_", 1)[1]) for key in tml_model_log_names})
 
-    select_all = st.toggle(
-        "Select all TML models", key=TMLExplainStateKeys.SelectAllTMLModels, value=False
-    )
-    selected_model_types = st.multiselect(
+    selected_model_types = multiselect_with_select_all(
         "Select TML model types to explain",
         options=all_model_types,
-        default=all_model_types if select_all else None,
         key=TMLExplainStateKeys.TMLModelSelector,
+        select_all_label="Select all TML models",
+        select_all_key=TMLExplainStateKeys.SelectAllTMLModels,
     )
 
     selected_reprs = st.multiselect(

{polynet-1.0.2 → polynet-1.0.3}/polynet/app/components/forms/representation.py

@@ -5,6 +5,7 @@ from rdkit import Chem
 from rdkit.Chem import Descriptors
 import streamlit as st
 
+from polynet.app.components.select_all import multiselect_with_select_all
 from polynet.app.options.allowable_sets import atom_properties, bond_features
 from polynet.app.options.state_keys import DescriptorCalculationStateKeys
 from polynet.app.utils import keep_only_numerical_columns
@@ -277,23 +278,16 @@ def molecular_descriptor_representation(
 
         st.markdown("### Calculate RDKit Molecular Descriptors")
 
-        select_all = st.checkbox(
-            "Select all descriptors",
-            value=not is_psmiles,
-            key=DescriptorCalculationStateKeys.SelectAllRDKitDescriptors,
-            help="If checked, all RDKit molecular descriptors will be selected by default. Uncheck to select specific descriptors.",
-        )
-
-        if select_all:
-            default_descriptors = all_descriptors
-        else:
-            default_descriptors = defaults.get(MolecularDescriptor.RDKit, [])
-
-        selected_descriptors = st.multiselect(
+        selected_descriptors = multiselect_with_select_all(
             "Select descriptors to calculate:",
             options=all_descriptors,
-            default=default_descriptors,  # Preselect common ones
             key=DescriptorCalculationStateKeys.DescriptorsRDKit,
+            select_all_label="Select all descriptors",
+            select_all_key=DescriptorCalculationStateKeys.SelectAllRDKitDescriptors,
+            select_all_default=not is_psmiles,
+            partial_selection=defaults.get(MolecularDescriptor.RDKit, []),
+            use_checkbox=True,
+            select_all_help="If checked, all RDKit molecular descriptors will be selected by default. Uncheck to select specific descriptors.",
             help="Choose which RDKit descriptors to compute for the molecules.",
         )
         st.info(f"You have selected {len((selected_descriptors))} RDKit descriptors.")
@@ -380,43 +374,37 @@ def molecular_descriptor_representation(
                 BACKBONE_TOPOLOGICAL_FEATURIZER_REGISTRY.keys()
             )
 
-            select_all_repeat_unit = st.checkbox(
-                "Select all repeat-unit descriptors",
-                value=True,
-                key=DescriptorCalculationStateKeys.SelectAllPMXRepeatUnit,
-                help="If checked, every repeat-unit descriptor is selected by default. Uncheck to choose specific descriptors.",
-            )
-            polymer_descriptors = st.multiselect(
+            polymer_descriptors = multiselect_with_select_all(
                 "Select the descriptors to calculate for the monomer repeat unit.",
                 options=repeat_unit_options,
-                default=repeat_unit_options if select_all_repeat_unit else None,
                 key=DescriptorCalculationStateKeys.PMXRepeatUnit,
+                select_all_label="Select all repeat-unit descriptors",
+                select_all_key=DescriptorCalculationStateKeys.SelectAllPMXRepeatUnit,
+                select_all_default=True,
+                use_checkbox=True,
+                select_all_help="If checked, every repeat-unit descriptor is selected by default. Uncheck to choose specific descriptors.",
             )
 
-            select_all_side_chain = st.checkbox(
-                "Select all side-chain descriptors",
-                value=True,
-                key=DescriptorCalculationStateKeys.SelectAllPMXSideChainDescriptors,
-                help="If checked, every side-chain descriptor is selected by default. Uncheck to choose specific descriptors.",
-            )
-            side_chain_descriptors = st.multiselect(
+            side_chain_descriptors = multiselect_with_select_all(
                 "Select the descriptors to calculate for the side chain of the polymers",
                 options=side_chain_options,
-                default=side_chain_options if select_all_side_chain else None,
                 key=DescriptorCalculationStateKeys.PMXSideChainDescriptors,
+                select_all_label="Select all side-chain descriptors",
+                select_all_key=DescriptorCalculationStateKeys.SelectAllPMXSideChainDescriptors,
+                select_all_default=True,
+                use_checkbox=True,
+                select_all_help="If checked, every side-chain descriptor is selected by default. Uncheck to choose specific descriptors.",
             )
 
-            select_all_backbone = st.checkbox(
-                "Select all backbone descriptors",
-                value=True,
-                key=DescriptorCalculationStateKeys.SelectAllPMXBackboneDescriptors,
-                help="If checked, every backbone descriptor is selected by default. Uncheck to choose specific descriptors.",
-            )
-            backbone_descriptors = st.multiselect(
+            backbone_descriptors = multiselect_with_select_all(
                 "Select the descriptors to calculate for the backbone of the polymers",
                 options=backbone_options,
-                default=backbone_options if select_all_backbone else None,
                 key=DescriptorCalculationStateKeys.PMXBackboneDescriptors,
+                select_all_label="Select all backbone descriptors",
+                select_all_key=DescriptorCalculationStateKeys.SelectAllPMXBackboneDescriptors,
+                select_all_default=True,
+                use_checkbox=True,
+                select_all_help="If checked, every backbone descriptor is selected by default. Uncheck to choose specific descriptors.",
             )
 
             agg_method = st.multiselect(
@@ -558,24 +546,20 @@ def graph_representation(
                 "removed from the options below."
             )
 
-        select_all_atomic = st.checkbox("Select all atomic properties")
-
-        if select_all_atomic:
-            default_atomic_properties = atomic_properties
-        else:
-            default_atomic_properties = [
+        selected_atomic_properties = multiselect_with_select_all(
+            "Select atomic properties to compute:",
+            options=atomic_properties,
+            key=DescriptorCalculationStateKeys.AtomProperties,
+            select_all_label="Select all atomic properties",
+            select_all_key=DescriptorCalculationStateKeys.SelectAllAtomProperties,
+            partial_selection=[
                 AtomFeature.GetAtomicNum,
                 AtomFeature.GetTotalNumHs,
                 AtomFeature.GetTotalDegree,
                 AtomFeature.GetImplicitValence,
                 AtomFeature.GetIsAromatic,
-            ]
-
-        selected_atomic_properties = st.multiselect(
-            "Select atomic properties to compute:",
-            options=atomic_properties,
-            default=default_atomic_properties,
-            key=DescriptorCalculationStateKeys.AtomProperties,
+            ],
+            use_checkbox=True,
             help="Choose which RDKit Atom-level properties to extract.",
         )
 
@@ -673,23 +657,17 @@ def graph_representation(
 
         st.markdown("#### Bond Properties")
 
-        select_all_bond = st.toggle("Select all bond properties")
-
-        if select_all_bond:
-            default_bond_properties = bond_properties
-
-        else:
-            default_bond_properties = [
-                BondFeature.GetBondTypeAsDouble,
-                BondFeature.GetIsAromatic,
-                BondFeature.GetStereo,
-            ]
-
-        selected_bond_properties = st.multiselect(
+        selected_bond_properties = multiselect_with_select_all(
             "Select bond properties to compute:",
             options=bond_properties,
-            default=default_bond_properties,
             key=DescriptorCalculationStateKeys.BondProperties,
+            select_all_label="Select all bond properties",
+            select_all_key=DescriptorCalculationStateKeys.SelectAllBondProperties,
+            partial_selection=[
+                BondFeature.GetBondTypeAsDouble,
+                BondFeature.GetIsAromatic,
+                BondFeature.GetStereo,
+            ],
             help="Choose which RDKit Bond-level properties to extract.",
         )
 

polynet-1.0.3/polynet/app/components/select_all.py

@@ -0,0 +1,73 @@
+"""
+polynet.app.components.select_all
+=================================
+A multiselect with a "select all" toggle or checkbox.
+
+Recent Streamlit versions keep a keyed widget's value when its ``default``
+changes, so a toggle that only changes the multiselect's ``default`` does
+nothing there. Here the toggle sets the selection itself, through the session
+state, when it is clicked.
+"""
+
+from collections.abc import Sequence
+
+import streamlit as st
+
+
+def multiselect_with_select_all(
+    label: str,
+    options: Sequence,
+    key: str,
+    *,
+    select_all_label: str,
+    select_all_key: str,
+    select_all_default: bool = False,
+    partial_selection: Sequence | None = None,
+    use_checkbox: bool = False,
+    select_all_help: str | None = None,
+    **multiselect_kwargs,
+) -> list:
+    """
+    Render a "select all" toggle (or checkbox) above a multiselect.
+
+    Switching it on selects every option; switching it off selects
+    ``partial_selection`` (nothing by default). The user can still edit the
+    selection afterwards.
+
+    Args:
+        label: Label of the multiselect.
+        options: The multiselect options.
+        key: Session-state key of the multiselect.
+        select_all_label: Label of the toggle.
+        select_all_key: Session-state key of the toggle.
+        select_all_default: Whether the toggle starts switched on.
+        partial_selection: Selection while the toggle is off.
+        use_checkbox: Show a checkbox instead of a toggle.
+        select_all_help: Help text of the toggle.
+        **multiselect_kwargs: Passed to ``st.multiselect`` (e.g. ``help``).
+
+    Returns:
+        The selected options.
+    """
+    options = list(options)
+    partial = [o for o in (partial_selection or []) if o in options]
+
+    def selection(select_all: bool) -> list:
+        return list(options) if select_all else list(partial)
+
+    def apply_select_all() -> None:
+        st.session_state[key] = selection(st.session_state[select_all_key])
+
+    (st.checkbox if use_checkbox else st.toggle)(
+        select_all_label,
+        value=select_all_default,
+        key=select_all_key,
+        help=select_all_help,
+        on_change=apply_select_all,
+    )
+    if key not in st.session_state:
+        st.session_state[key] = selection(st.session_state[select_all_key])
+    else:
+        # Options can change between runs (e.g. another experiment).
+        st.session_state[key] = [o for o in st.session_state[key] if o in options]
+    return st.multiselect(label, options=options, key=key, **multiselect_kwargs)

{polynet-1.0.2 → polynet-1.0.3}/polynet/app/options/state_keys.py

@@ -58,6 +58,8 @@ class DescriptorCalculationStateKeys(StrEnum):
     SelectAllPMXBackboneDescriptors = "SelectAllPMXBackboneDescriptors"
     AtomProperties = "AtomProperties"
     BondProperties = "BondProperties"
+    SelectAllAtomProperties = "SelectAllAtomProperties"
+    SelectAllBondProperties = "SelectAllBondProperties"
     ShowFrequency = "ShowFrequency"
 
 

{polynet-1.0.2 → polynet-1.0.3}/polynet/featurizer/descriptors.py

@@ -531,7 +531,13 @@ def get_polybert_fingerprints(
 
     canonicalize = import_psmiles_canonicaliser()
 
-    model = SentenceTransformer(POLYBERT_MODEL)
+    import torch
+
+    # Same device rule as GNN training (CUDA or CPU). sentence-transformers would
+    # otherwise use Apple's MPS, whose embeddings differ slightly from the CPU ones
+    # (so results would depend on the machine) and are NaN on some virtual Macs.
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model = SentenceTransformer(POLYBERT_MODEL, device=device)
 
     # 1) Canonicalize (keep a mapping from original -> canonical)
     orig_to_canon: dict[str, str] = {}

{polynet-1.0.2 → polynet-1.0.3}/polynet/pipeline/self_check.py

@@ -9,6 +9,10 @@ dataset, once for regression and once for classification, in a temporary
 folder, and prints a PASS / FAIL table that can be pasted into a bug report.
 The regression run also explains the models and predicts on new data.
 
+XGBoost is first trained in a separate process with PyTorch loaded: on macOS
+two OpenMP runtimes in one process crash it, which would end the check before
+its report. The pipeline runs train XGBoost only if that passes.
+
 Usage
 -----
     polynet check                 # about a minute on a laptop
@@ -25,6 +29,8 @@ import logging
 from pathlib import Path
 import platform
 import shutil
+import subprocess
+import sys
 import tempfile
 import time
 import warnings
@@ -108,11 +114,16 @@ def synthetic_copolymers(n_samples: int, problem_type: str, seed: int = 42) -> p
 
 
 def check_config(
-    problem_type: str, data_path: Path, out_dir: Path, epochs: int, predict_path: Path | None
+    problem_type: str,
+    data_path: Path,
+    out_dir: Path,
+    epochs: int,
+    predict_path: Path | None,
+    xgboost: bool = True,
 ) -> dict:
     """
-    Return a small but complete pipeline config: GCN and random forest on
-    Morgan fingerprints, two repeated splits.
+    Return a small but complete pipeline config: GCN, random forest and
+    XGBoost on Morgan fingerprints, two repeated splits.
 
     Args:
         problem_type (str): ``"regression"`` or ``"classification"``.
@@ -121,6 +132,7 @@ def check_config(
         epochs (int): GNN training epochs.
         predict_path (Path | None): CSV to predict after training; when given,
             the models are also explained.
+        xgboost (bool): Also train XGBoost.
 
     Returns:
         dict: The config, as ``polynet run`` reads it from YAML.
@@ -175,7 +187,10 @@ def check_config(
         "feature_preprocessing": {"scaler": "standard_scaler"},
         "tml_models": {
             "train_tml": True,
-            "selected_models": {"random_forest": {"n_estimators": 20, "max_depth": 3}},
+            "selected_models": {
+                "random_forest": {"n_estimators": 20, "max_depth": 3},
+                **({"xgboost": {"n_estimators": 20, "max_depth": 3}} if xgboost else {}),
+            },
         },
         "explainability": {"enabled": explain, "fragmentation": "brics", "top_n": 5},
         "tml_explainability": {"enabled": explain, "top_n": 5},
@@ -223,8 +238,47 @@ def _check_psmiles() -> CheckResult:
     return CheckResult("PSMILES canonicaliser", "PASS", "installed and working")
 
 
+# Trains XGBoost the way the pipeline does: after PyTorch has been imported.
+_XGBOOST_WITH_TORCH = """
+import numpy as np
+import torch  # noqa: F401
+import xgboost
+X = np.random.default_rng(0).normal(size=(200, 10))
+xgboost.XGBRegressor(n_estimators=10).fit(X, X[:, 0])
+"""
+
+
+def _check_xgboost_with_torch() -> CheckResult:
+    """Train XGBoost with PyTorch loaded, in a separate process that may crash."""
+    name = "XGBoost with PyTorch loaded"
+    try:
+        run = subprocess.run(
+            [sys.executable, "-c", _XGBOOST_WITH_TORCH], capture_output=True, text=True, timeout=300
+        )
+    except subprocess.TimeoutExpired:
+        return CheckResult(name, "FAIL", "did not finish within 5 minutes")
+    if run.returncode == 0:
+        return CheckResult(name, "PASS")
+    if run.returncode < 0:  # killed by a signal, e.g. a segmentation fault
+        detail = f"crashed (signal {-run.returncode})"
+        if platform.system() == "Darwin":
+            detail += (
+                "; on macOS this is usually two OpenMP runtimes (PyTorch's and XGBoost's). "
+                'Install a compatible PyTorch: pip install "torch<2.11"'
+            )
+    else:
+        detail = (run.stderr.strip().splitlines() or [f"exit code {run.returncode}"])[-1]
+    return CheckResult(name, "FAIL", detail + ". XGBoost is left out of the runs below.")
+
+
 def _check_pipeline(
-    name: str, problem_type: str, work_dir: Path, epochs: int, n_samples: int, predict: bool
+    name: str,
+    problem_type: str,
+    work_dir: Path,
+    epochs: int,
+    n_samples: int,
+    predict: bool,
+    xgboost: bool = True,
 ) -> CheckResult:
     from polynet.pipeline.runner import main as run_pipeline
 
@@ -243,7 +297,9 @@ def _check_pipeline(
     out_dir = run_dir / "results"
     config_path = run_dir / "config.yaml"
     with open(config_path, "w") as f:
-        yaml.safe_dump(check_config(problem_type, data_path, out_dir, epochs, predict_path), f)
+        yaml.safe_dump(
+            check_config(problem_type, data_path, out_dir, epochs, predict_path, xgboost), f
+        )
 
     collector = _ErrorCollector()
     polynet_logger = logging.getLogger("polynet")
@@ -325,7 +381,8 @@ def main(argv: list[str] | None = None) -> int:
 
     results = [_check_packages()]
     if results[0].status == "PASS":
-        results += [_check_device(), _check_psmiles()]
+        results += [_check_device(), _check_psmiles(), _check_xgboost_with_torch()]
+        xgboost = results[-1].status == "PASS"
 
         work_dir = Path(tempfile.mkdtemp(prefix="polynet_check_"))
         pipeline_checks = [
@@ -335,7 +392,9 @@ def main(argv: list[str] | None = None) -> int:
         for name, problem_type, predict in pipeline_checks:
             print(f"  running {name.lower()}…")
             results.append(
-                _check_pipeline(name, problem_type, work_dir, args.epochs, args.samples, predict)
+                _check_pipeline(
+                    name, problem_type, work_dir, args.epochs, args.samples, predict, xgboost
+                )
             )
 
         failed = any(r.status == "FAIL" for r in results)

{polynet-1.0.2 → polynet-1.0.3}/polynet/visualization/plots.py

@@ -458,7 +458,7 @@ def plot_bootstrap_boxplots(
     fig, ax = plt.subplots(figsize=(height, width), dpi=dpi)
     ax.boxplot(
         data,
-        labels=model_names,
+        tick_labels=model_names,  # `labels` was removed in Matplotlib 3.11
         patch_artist=True,
         boxprops=dict(facecolor=fill_colour, color=border_colour),
         medianprops=dict(color=median_colour, linewidth=2),

{polynet-1.0.2 → polynet-1.0.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "polynet"
-version = "1.0.2"
+version = "1.0.3"
 description = "A Python package for polymer informatics: property prediction with graph neural networks and traditional machine learning"
 authors = [
   { name = "Eduardo Aguilar-Bejarano", email = "eduardo.aguilar-bejarano@nottingham.ac.uk" },
@@ -19,7 +19,10 @@ dependencies = [
   "pandas>=2.2.3,<3.0.0",
   "rdkit>=2025.3.2,<2026.0.0",
   "torch==2.2.0 ; sys_platform == 'darwin' and platform_machine == 'x86_64'",
-  "torch>=2.5.1,<3.0.0 ; sys_platform != 'darwin' or platform_machine != 'x86_64'",
+  # Apple silicon: from torch 2.11 the bundled libomp is no longer named like Homebrew's,
+  # so XGBoost loads a second OpenMP runtime and crashes once torch is imported.
+  "torch>=2.5.1,<2.11 ; sys_platform == 'darwin' and platform_machine == 'arm64'",
+  "torch>=2.5.1,<3.0.0 ; sys_platform != 'darwin'",
   "torch-geometric==2.7",
   "scikit-learn>=1.6.1,<2.0.0",
   "matplotlib>=3.10.3,<4.0.0",