papyrus-scripts 3.0.1__tar.gz → 3.0.2__tar.gz

{papyrus_scripts-3.0.1/src/papyrus_scripts.egg-info → papyrus_scripts-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: papyrus_scripts
-Version: 3.0.1
+Version: 3.0.2
 Summary: A collection of scripts to handle the Papyrus bioactivity dataset
 Author: Brandon J. Bongers, Willem Jespers
 Author-email: "Olivier J. M. Béquignon" <olivier.bequignon.maintainer@gmail.com>
@@ -104,6 +104,12 @@ Optional extras enable additional functionality:
 > **Note:** `openbabel` (needed only for FP2/FP3/FP4 fingerprints) must be installed via conda-forge, not pip, when used alongside RDKit/FPSim2/cupy in the same environment: `conda install -c conda-forge openbabel`.
 >
 > **Note:** the `gpu` extra pins `cupy-cuda12x[ctk]`, whose `ctk` extra pulls in the CUDA 12.x toolkit as a pip package — no separate toolkit install needed, only an NVIDIA driver compatible with CUDA 12.x.
+>
+> **Note:** on Windows, plain `pip install papyrus-scripts[dnn]` installs a CPU-only PyTorch build — CUDA-enabled Windows wheels aren't published on PyPI, only on PyTorch's own index. Get GPU support with:
+> ```
+> pip install papyrus-scripts[dnn] --extra-index-url https://download.pytorch.org/whl/cu130
+> ```
+> (swap `cu130` for the CUDA tag matching your driver; see the [PyTorch install matrix](https://pytorch.org/get-started/locally/)). On Linux, the plain PyPI wheel already bundles CUDA, so no extra index is needed there.
 
 ## 🛠️ Requirements
 

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/README.md

@@ -52,6 +52,12 @@ Optional extras enable additional functionality:
 > **Note:** `openbabel` (needed only for FP2/FP3/FP4 fingerprints) must be installed via conda-forge, not pip, when used alongside RDKit/FPSim2/cupy in the same environment: `conda install -c conda-forge openbabel`.
 >
 > **Note:** the `gpu` extra pins `cupy-cuda12x[ctk]`, whose `ctk` extra pulls in the CUDA 12.x toolkit as a pip package — no separate toolkit install needed, only an NVIDIA driver compatible with CUDA 12.x.
+>
+> **Note:** on Windows, plain `pip install papyrus-scripts[dnn]` installs a CPU-only PyTorch build — CUDA-enabled Windows wheels aren't published on PyPI, only on PyTorch's own index. Get GPU support with:
+> ```
+> pip install papyrus-scripts[dnn] --extra-index-url https://download.pytorch.org/whl/cu130
+> ```
+> (swap `cu130` for the CUDA tag matching your driver; see the [PyTorch install matrix](https://pytorch.org/get-started/locally/)). On Linux, the plain PyPI wheel already bundles CUDA, so no extra index is needed there.
 
 ## 🛠️ Requirements
 

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/__init__.py

@@ -35,4 +35,4 @@ from .utils import IO, UniprotMatch
 from .utils.IO import PapyrusVersion
 from .utils.mol_reader import MolSupplier
 
-__version__ = '3.0.1'
+__version__ = '3.0.2'

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/fingerprint.py

@@ -4,8 +4,10 @@
 
 from __future__ import annotations
 
+import contextlib
 import hashlib
 import json
+import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Callable
 from typing import Any
@@ -20,8 +22,27 @@ try:
     HAS_PYBEL = True
 except ImportError:  # pragma: no cover - only taken when openbabel isn't installed
     HAS_PYBEL = False
+
+
+@contextlib.contextmanager
+def _suppress_missing_cuda_path_warning():
+    """Silence cupy's harmless "CUDA path could not be detected" warning, nothing else."""
+    with warnings.catch_warnings():
+        warnings.filterwarnings(
+            'ignore',
+            message=r'^CUDA path could not be detected\.',
+            category=UserWarning,
+            module=r'^cupy(\..*)?$',
+        )
+        yield
+
+
 try:
-    from FPSim2.FPSim2lib.utils import BitStrToIntList, PyPopcount
+    # Importing any FPSim2 submodule runs FPSim2/__init__.py, which
+    # unconditionally imports cupy - this is the first FPSim2 import in the
+    # package's import chain, so the warning suppression belongs here.
+    with _suppress_missing_cuda_path_warning():
+        from FPSim2.FPSim2lib.utils import BitStrToIntList, PyPopcount
     HAS_FPSIM2 = True  # pragma: no cover - only taken when FPSim2 is installed
 except ImportError:
     HAS_FPSIM2 = False

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/modelling.py

@@ -377,7 +377,9 @@ def _fit_and_evaluate(data: pd.DataFrame,
         crossvalidate_model's per-fold-plus-"Full model" dict
     """
     if split_by.lower() == 'year':
-        test_set = data[data['Year'] >= split_year]
+        # 'Year' may come in as string/object dtype
+        years = pd.to_numeric(data['Year'], errors='coerce')
+        test_set = data[years >= split_year]
         if test_set.empty:
             raise _InsufficientDataError(f'No test data for temporal split at {split_year}')
         training_set = data[~data.index.isin(test_set.index)]
@@ -400,7 +402,8 @@ def _fit_and_evaluate(data: pd.DataFrame,
     elif split_by.lower() == 'cluster':
         if cluster_method is None:
             raise RuntimeError('cluster_method missing despite qsar()/pcm() validating it upfront')
-        groups = cluster_method.fit_predict(data.drop(columns=features_to_ignore))
+        # errors='ignore': merge_on/target_id are already dropped from data by this point
+        groups = cluster_method.fit_predict(data.drop(columns=features_to_ignore, errors='ignore'))
         training_set, test_set, training_groups, _ = train_test_proportional_group_split(data, groups,
                                                                                          test_set_size,
                                                                                          verbose=verbose)
@@ -450,6 +453,10 @@ def _fit_and_evaluate(data: pd.DataFrame,
                                random_state=random_state).to_pandas()
         test_set.index = test_index
     # Make sure enough data
+    # (applies to every split_by mode, not just 'year')
+    if training_set.shape[0] < folds:
+        raise _InsufficientDataError(
+            f'Not enough training data ({training_set.shape[0]} rows) for {folds} folds')
     if model_type == 'classifier':
         train_data_classes = Counter(training_set[endpoint])
         if not np.all(np.array(list(train_data_classes.values())) > folds):

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/neuralnet.py

@@ -25,6 +25,7 @@ try:
     from skorch.callbacks import Checkpoint, EarlyStopping, LRScheduler
     from skorch.dataset import Dataset as SkorchDataset
     from skorch.helper import predefined_split
+    from skorch.utils import to_tensor
     from torch import nn
     HAS_TORCH = True
 except ImportError:  # pragma: no cover - exercised only when torch/skorch aren't installed
@@ -151,6 +152,7 @@ class BaseNN:
         # subclass (see SingleTaskNNClassifier etc.), which supplies the
         # rest of this __init__ signature and the fit/predict_proba/
         # initialize members used below - invisible to mypy from here.
+        kwargs.setdefault('device', _default_device())  # allow overriding via device= kwarg
         super().__init__(  # type: ignore[call-arg]
             module=_MLP,
             optimizer=torch.optim.Adam,
@@ -160,7 +162,6 @@ class BaseNN:
             callbacks=callbacks,
             callbacks__valid_acc=None,  # replaced by our own early-stopping/checkpoint logic
             predict_nonlinearity=None,  # real value set per-subclass, see set_architecture()/__init__
-            device=_default_device(),
             train_split=None,  # require an explicit validation set, see set_validation()
             **kwargs,
         )
@@ -305,6 +306,7 @@ class SingleTaskNNRegressor(BaseNN, skorch.NeuralNetRegressor if HAS_TORCH else
 
     def __init__(self, *args, **kwargs) -> None:
         """Neural Network regressor to predict a unique endpoint."""
+        _require_torch()
         super().__init__(*args, criterion=nn.MSELoss, **kwargs)
 
     def set_architecture(self, n_dim: int) -> None:
@@ -315,14 +317,28 @@ class SingleTaskNNRegressor(BaseNN, skorch.NeuralNetRegressor if HAS_TORCH else
         self._dims = [n_dim, *self.hidden_layers, 1]
 
 
-class MultiTaskNNClassifier(BaseNN, skorch.NeuralNetClassifier if HAS_TORCH else object):  # type: ignore[misc]
-    """Neural Network classifier to predict multiple (independent, binary) endpoints."""
+class _MaskedMultiTaskLoss:
+    """Mixin: excludes ``NaN`` targets from the loss, so sparse multi-task rows need no imputation."""
+
+    def get_loss(self, y_pred, y_true, X=None, training=False):
+        """Mean loss over non-``NaN`` targets; requires criterion(reduction='none')."""
+        y_true = to_tensor(y_true, device=self.device)
+        mask = ~torch.isnan(y_true)
+        if isinstance(self.criterion_, torch.nn.Module):
+            self.criterion_.train(training)
+        elementwise = self.criterion_(y_pred, torch.where(mask, y_true, torch.zeros_like(y_true)))
+        return (elementwise * mask).sum() / mask.sum().clamp(min=1)
+
+
+class MultiTaskNNClassifier(_MaskedMultiTaskLoss, BaseNN,
+                             skorch.NeuralNetClassifier if HAS_TORCH else object):  # type: ignore[misc]
+    """Neural Network classifier to predict multiple (independent, binary) endpoints; supports ``NaN`` labels."""
 
     def __init__(self, *args, **kwargs) -> None:
         """Neural Network classifier to predict multiple endpoints."""
-        # Raw logits + BCEWithLogitsLoss (see SingleTaskNNClassifier for why);
-        # probabilities are produced post-hoc via predict_nonlinearity.
-        super().__init__(*args, criterion=nn.BCEWithLogitsLoss, **kwargs)
+        _require_torch()
+        # Raw logits + BCEWithLogitsLoss (see SingleTaskNNClassifier); reduction='none' for masking.
+        super().__init__(*args, criterion=nn.BCEWithLogitsLoss, criterion__reduction='none', **kwargs)
         self.predict_nonlinearity = torch.sigmoid
 
     def set_architecture(self, n_dim: int, n_task: int) -> None:
@@ -350,12 +366,14 @@ class MultiTaskNNClassifier(BaseNN, skorch.NeuralNetClassifier if HAS_TORCH else
         return np.round(self.predict_proba(X))
 
 
-class MultiTaskNNRegressor(BaseNN, skorch.NeuralNetRegressor if HAS_TORCH else object):  # type: ignore[misc]
-    """Neural Network regressor to predict multiple endpoints."""
+class MultiTaskNNRegressor(_MaskedMultiTaskLoss, BaseNN,
+                            skorch.NeuralNetRegressor if HAS_TORCH else object):  # type: ignore[misc]
+    """Neural Network regressor to predict multiple endpoints; supports ``NaN`` targets."""
 
     def __init__(self, *args, **kwargs) -> None:
         """Neural Network regressor to predict multiple endpoints."""
-        super().__init__(*args, criterion=nn.MSELoss, **kwargs)
+        _require_torch()
+        super().__init__(*args, criterion=nn.MSELoss, criterion__reduction='none', **kwargs)  # 'none' for masking
 
     def set_architecture(self, n_dim: int, n_task: int) -> None:
         """Set dimension of input and number of tasks to be predicted.

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/oop.py

@@ -427,6 +427,7 @@ class PapyrusDataset:
             chunksize: int | None = None,
             keep_original_files: bool = False,
             disk_margin: float = 0.10,
+            download_if_missing: bool = False,
     ) -> PapyrusDataset:
         """Create a :class:`PapyrusDataset` from an existing DataFrame.
 
@@ -443,6 +444,11 @@ class PapyrusDataset:
             lazily through this dataset (default: False)
         :param disk_margin: safety margin for any download later triggered
             through this dataset (default: 0.10)
+        :param download_if_missing: download the protein-target file if not
+            found locally, instead of raising (default: False)
+        :raises FileNotFoundError | NotADirectoryError | OSError | ValueError:
+            if the protein-target file isn't found and *download_if_missing*
+            is False
         :returns: a :class:`PapyrusDataset` wrapping *df*
         """
         pv = _ensure_papyrus_version(version)
@@ -450,9 +456,24 @@ class PapyrusDataset:
             df = pl.from_pandas(df)
         dataset = PapyrusDataset.__new__(PapyrusDataset)
         dataset.papyrus_bioactivity_data = df
-        dataset.papyrus_protein_data = reader.read_protein_set(
-            source_path=source_path, version=pv,
-        )
+        try:
+            dataset.papyrus_protein_data = reader.read_protein_set(
+                source_path=source_path, version=pv,
+            )
+        except _NOT_AVAILABLE_LOCALLY:
+            if not download_if_missing:
+                raise
+            download.download_papyrus(
+                outdir=source_path,
+                version=pv.pystow_path_key,  # not .version: must match the folder key reads use
+                nostereo=not is3d, stereo=is3d, only_pp=plusplus,
+                structures=False, descriptors=None,
+                progress=download_progress, disk_margin=disk_margin,
+                keep_xz=keep_original_files,
+            )
+            dataset.papyrus_protein_data = reader.read_protein_set(
+                source_path=source_path, version=pv,
+            )
         dataset.papyrus_params = dict(
             is3d=is3d, version=pv, plusplus=plusplus,
             chunksize=chunksize, source_path=source_path,

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/preprocess.py

@@ -26,7 +26,7 @@ DataOutput = pl.DataFrame | pl.LazyFrame
 _JoinHow = Literal['inner', 'left', 'right', 'full', 'semi', 'anti', 'cross', 'outer']
 _ConcatHow = Literal[
     'vertical', 'vertical_relaxed', 'diagonal', 'diagonal_relaxed',
-    'horizontal', 'align', 'align_full', 'align_inner',
+    'horizontal', 'horizontal_extend', 'align', 'align_full', 'align_inner',
     'align_left', 'align_right',
 ]
 
@@ -736,10 +736,7 @@ def keep_protein_class(
         return data.filter(pl.lit(False))
 
     # level_frames always share len(protein_data) rows, so this never pads.
-    # 'horizontal_extend' only exists in very recent polars releases (absent
-    # e.g. on Google Colab's pinned version); 'horizontal' is available
-    # everywhere and behaves identically here since heights always match.
-    split_classes = pl.concat(level_frames, how='horizontal')
+    split_classes = pl.concat(level_frames, how='horizontal_extend')
 
     # Build the boolean mask over protein rows.
     mask = pl.Series([False] * len(split_classes))

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/subsim_search.py

@@ -27,6 +27,8 @@ from rdkit import Chem
 from rdkit.Chem.rdSubstructLibrary import CachedSmilesMolHolder, PatternHolder, SubstructLibrary
 from tqdm.auto import tqdm
 
+from .fingerprint import Fingerprint, MorganFingerprint, _suppress_missing_cuda_path_warning, get_fp_from_name
+
 try:
     import tables as tb
     HAS_TABLES = True  # pragma: no cover - exercised only with pytables installed
@@ -36,15 +38,16 @@ except ImportError:
 try:
     # This whole block only runs with FPSim2 installed; every line below the
     # first import is unreachable otherwise (the first import raises first).
-    from FPSim2.base import BaseEngine  # pragma: no cover
-    from FPSim2.FPSim2 import FPSim2Engine
-    from FPSim2.io.backends.base import BaseStorageBackend  # pragma: no cover
-    from FPSim2.io.backends.pytables import (  # pragma: no cover
-        BATCH_WRITE_SIZE,
-        calc_popcnt_bins_pytables,
-        create_schema,
-    )
-    from FPSim2.io.chem import load_molecule  # pragma: no cover
+    with _suppress_missing_cuda_path_warning():
+        from FPSim2.base import BaseEngine  # pragma: no cover
+        from FPSim2.FPSim2 import FPSim2Engine
+        from FPSim2.io.backends.base import BaseStorageBackend  # pragma: no cover
+        from FPSim2.io.backends.pytables import (  # pragma: no cover
+            BATCH_WRITE_SIZE,
+            calc_popcnt_bins_pytables,
+            create_schema,
+        )
+        from FPSim2.io.chem import load_molecule  # pragma: no cover
     HAS_FPSIM2 = True  # pragma: no cover
 except ImportError:
     HAS_FPSIM2 = False
@@ -65,12 +68,12 @@ try:
     # FPSim2.FPSim2Cuda unconditionally imports cupy, so this is kept
     # separate from HAS_FPSIM2 above: a missing GPU stack must not disable
     # CPU-only search.
-    from FPSim2.FPSim2Cuda import FPSim2CudaEngine  # pragma: no cover
+    with _suppress_missing_cuda_path_warning():
+        from FPSim2.FPSim2Cuda import FPSim2CudaEngine  # pragma: no cover
 except ImportError:
     class FPSim2CudaEngine:  # type: ignore[no-redef]
         """Stub for FPSim2.FPSim2Cuda.FPSim2CudaEngine when cupy is absent."""
 
-from .fingerprint import Fingerprint, MorganFingerprint, get_fp_from_name
 from .utils.IO import PapyrusVersion, _prefer_parquet, _set_root_folder, get_num_rows_in_file, locate_file
 from .utils.mol_reader import MolSupplier
 

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/src/papyrus_scripts/utils/IO.py

@@ -294,6 +294,11 @@ def to_polars_schema(dtypes: dict) -> dict:
     return {col: to_polars_dtype(t) for col, t in dtypes.items()}
 
 
+#: 'Year' is absent from shipped data_types.json (unlike 'all_years', a
+#: semicolon-joined list, it's always a clean single integer or null).
+_EXTRA_PAPYRUS_SCHEMA_OVERRIDES: dict = {'Year': pl.Int32}
+
+
 def load_data_type_schemas(source_module: pystow.Module) -> dict:
     """Read a version folder's ``data_types.json`` and return ``{section: {col: polars_dtype}}``.
 
@@ -302,10 +307,14 @@ def load_data_type_schemas(source_module: pystow.Module) -> dict:
     dtype_file = source_module.join(name='data_types.json')
     with open(dtype_file) as fh:
         raw = json.load(fh, cls=TypeDecoder)
-    return {
+    schemas = {
         key: to_polars_schema(val) if isinstance(val, dict) else val
         for key, val in raw.items()
     }
+    if 'papyrus' in schemas:
+        for col, dtype in _EXTRA_PAPYRUS_SCHEMA_OVERRIDES.items():
+            schemas['papyrus'].setdefault(col, dtype)
+    return schemas
 
 
 # ---------------------------------------------------------------------------
@@ -1097,7 +1106,8 @@ def _downcast_integer_overrides(
         ``None`` if every eligible column downcast cleanly.
     """
     for col, target in overrides.items():
-        if target not in _NULLABLE_INT_DTYPES or col in forced_float_cols:
+        # A shared schema may name a column one file variant lacks.
+        if col not in chunk.columns or target not in _NULLABLE_INT_DTYPES or col in forced_float_cols:
             continue
         non_null = chunk[col].dropna()
         if len(non_null) == 0 or (non_null % 1 == 0).all():

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2/src/papyrus_scripts.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: papyrus_scripts
-Version: 3.0.1
+Version: 3.0.2
 Summary: A collection of scripts to handle the Papyrus bioactivity dataset
 Author: Brandon J. Bongers, Willem Jespers
 Author-email: "Olivier J. M. Béquignon" <olivier.bequignon.maintainer@gmail.com>
@@ -104,6 +104,12 @@ Optional extras enable additional functionality:
 > **Note:** `openbabel` (needed only for FP2/FP3/FP4 fingerprints) must be installed via conda-forge, not pip, when used alongside RDKit/FPSim2/cupy in the same environment: `conda install -c conda-forge openbabel`.
 >
 > **Note:** the `gpu` extra pins `cupy-cuda12x[ctk]`, whose `ctk` extra pulls in the CUDA 12.x toolkit as a pip package — no separate toolkit install needed, only an NVIDIA driver compatible with CUDA 12.x.
+>
+> **Note:** on Windows, plain `pip install papyrus-scripts[dnn]` installs a CPU-only PyTorch build — CUDA-enabled Windows wheels aren't published on PyPI, only on PyTorch's own index. Get GPU support with:
+> ```
+> pip install papyrus-scripts[dnn] --extra-index-url https://download.pytorch.org/whl/cu130
+> ```
+> (swap `cu130` for the CUDA tag matching your driver; see the [PyTorch install matrix](https://pytorch.org/get-started/locally/)). On Linux, the plain PyPI wheel already bundles CUDA, so no extra index is needed there.
 
 ## 🛠️ Requirements
 

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/tests/test_modelling.py

@@ -271,6 +271,20 @@ class TestFitAndEvaluateSplitModes(unittest.TestCase):
         ))
         self.assertIn('Test set', performance.index)
 
+    def test_cluster_split_tolerates_already_dropped_features_to_ignore_columns(self):
+        # Regression: features_to_ignore may list columns already dropped from data
+        from sklearn.cluster import KMeans
+        n = 12
+        data = pd.DataFrame({
+            'y': range(1, n + 1), 'Year': [2010] * n,
+            'f1': [0.0] * 6 + [10.0] * 6, 'f2': [0.0] * 6 + [10.0] * 6,
+        })
+        performance, _, _ = _fit_and_evaluate(**self._kwargs(
+            data, split_by='cluster', cluster_method=KMeans(n_clusters=2, random_state=0, n_init=1),
+            features_to_ignore=['id', 'target_id', 'y', 'Year'],
+        ))
+        self.assertIn('Test set', performance.index)
+
     def test_custom_split(self):
         n = 10
         data = pd.DataFrame({'y': range(1, n + 1), 'Year': [2010] * n, 'f1': range(n), 'f2': range(n)})
@@ -298,6 +312,61 @@ class TestFitAndEvaluateSplitModes(unittest.TestCase):
         performance, _, _ = _fit_and_evaluate(**self._kwargs(data, yscramble=True))
         self.assertIn('Test set', performance.index)
 
+    def test_random_split_without_scrambling_fits_a_model(self):
+        n = 20
+        data = pd.DataFrame({
+            'y': list(range(1, n + 1)), 'Year': [2010] * n,
+            'f1': range(n), 'f2': range(n),
+        })
+        performance, _, cv_models = _fit_and_evaluate(**self._kwargs(data, split_by='random'))
+        self.assertIn('Test set', performance.index)
+        self.assertIn('Full model', cv_models)
+
+    def test_yscramble_permutes_training_labels_relative_to_features(self):
+        # must actually permute y, not leave it untouched
+        n = 20
+        data = pd.DataFrame({
+            'y': list(range(1, n + 1)), 'Year': [2010] * n,
+            'f1': range(n), 'f2': range(n),
+        })
+        from src.papyrus_scripts import modelling as modelling_mod
+        original_cvm = modelling_mod.crossvalidate_model
+        captured: dict[str, pd.Series] = {}
+
+        def _recording_cvm(data_arg, *args, **kwargs):
+            captured['y'] = data_arg.iloc[:, 0].copy()
+            return original_cvm(data_arg, *args, **kwargs)
+
+        with patch('src.papyrus_scripts.modelling.crossvalidate_model', side_effect=_recording_cvm):
+            _fit_and_evaluate(**self._kwargs(data, yscramble=False))
+            unscrambled_y = captured['y']
+            _fit_and_evaluate(**self._kwargs(data, yscramble=True))
+            scrambled_y = captured['y']
+        self.assertEqual(sorted(unscrambled_y.tolist()), sorted(scrambled_y.tolist()))
+        self.assertFalse((unscrambled_y.values == scrambled_y.values).all())
+
+    def test_random_split_insufficient_training_data_for_folds_raises(self):
+        # regression: this check used to only apply to split_by='year'
+        n = 5
+        data = pd.DataFrame({
+            'y': range(n), 'Year': [2010] * n, 'f1': range(n), 'f2': range(n),
+        })
+        with self.assertRaises(_InsufficientDataError):
+            _fit_and_evaluate(**self._kwargs(data, split_by='random', test_set_size=0.3, folds=5))
+
+    def test_cluster_split_insufficient_training_data_for_folds_raises(self):
+        from sklearn.cluster import KMeans
+        n = 5
+        data = pd.DataFrame({
+            'y': range(n), 'Year': [2010] * n,
+            'f1': [0.0, 0.0, 10.0, 10.0, 10.0], 'f2': [0.0, 0.0, 10.0, 10.0, 10.0],
+        })
+        with self.assertRaises(_InsufficientDataError):
+            _fit_and_evaluate(**self._kwargs(
+                data, split_by='cluster', folds=5,
+                cluster_method=KMeans(n_clusters=2, random_state=0, n_init=1),
+            ))
+
     def test_stratified_classifier_scale_return_val(self):
         n = 20
         data = pd.DataFrame({
@@ -434,6 +503,98 @@ class TestQsarPcmValidation(unittest.TestCase):
             with self.assertRaises(ValueError):
                 pcm(data, num_points=3, split_year=2030)
 
+    def test_pcm_single_protein_across_multiple_compounds(self):
+        # _make_bioactivity_data() has a single target (T1) for all rows
+        with (
+            patch(
+                'src.papyrus_scripts.modelling.read_molecular_descriptors',
+                return_value=pl.LazyFrame(_make_descriptors()),
+            ),
+            patch(
+                'src.papyrus_scripts.modelling.read_protein_descriptors',
+                return_value=pd.DataFrame({'target_id': ['T1'], 'Prot_1': [0.0]}),
+            ) as mock_prot,
+        ):
+            performance, return_val = pcm(
+                pd.DataFrame(_make_bioactivity_data()), num_points=3, folds=2, split_year=2016,
+            )
+        mock_prot.assert_called_once()
+        self.assertIn('Test set', performance.index)
+        self.assertIn('Full model', return_val)
+
+    def test_qsar_random_split_completes(self):
+        with patch(
+            'src.papyrus_scripts.modelling.read_molecular_descriptors',
+            return_value=pl.LazyFrame(_make_descriptors()),
+        ):
+            results, _ = qsar(pd.DataFrame(_make_bioactivity_data()), model=DecisionTreeRegressor(random_state=0),
+                              num_points=3, folds=2, split_by='random', verbose=False)
+        self.assertIn('Test set', results.loc['T1'].index)
+
+    def test_pcm_random_split_completes(self):
+        with (
+            patch(
+                'src.papyrus_scripts.modelling.read_molecular_descriptors',
+                return_value=pl.LazyFrame(_make_descriptors()),
+            ),
+            patch(
+                'src.papyrus_scripts.modelling.read_protein_descriptors',
+                return_value=pd.DataFrame({'target_id': ['T1'], 'Prot_1': [0.0]}),
+            ),
+        ):
+            performance, _ = pcm(pd.DataFrame(_make_bioactivity_data()), model=DecisionTreeRegressor(random_state=0),
+                                 num_points=3, folds=2, split_by='random', verbose=False)
+        self.assertIn('Test set', performance.index)
+
+    def test_pcm_random_split_insufficient_data_raises_valueerror_not_raw_sklearn_error(self):
+        # regression: same fix as test_random_split_insufficient_training_data_for_folds_raises
+        n = 5
+        data = pd.DataFrame({
+            'connectivity': [f'C{i}' for i in range(n)],
+            'target_id': ['T1'] * n,
+            'Activity_class': [None] * n,
+            'pchembl_value_Mean': [5.0, 5.2, 5.4, 7.0, 7.6],
+            'relation': ['='] * n,
+            'Year': [2010] * n,
+        })
+        with (
+            patch(
+                'src.papyrus_scripts.modelling.read_molecular_descriptors',
+                return_value=pl.LazyFrame({'connectivity': [f'C{i}' for i in range(n)],
+                                           'Desc_1': [i / n for i in range(n)]}),
+            ),
+            patch(
+                'src.papyrus_scripts.modelling.read_protein_descriptors',
+                return_value=pd.DataFrame({'target_id': ['T1'], 'Prot_1': [0.0]}),
+            ),
+        ):
+            with self.assertRaisesRegex(ValueError, 'Not enough training data'):
+                pcm(data, num_points=3, folds=5, split_by='random', verbose=False)
+
+    def test_qsar_random_split_insufficient_data_for_one_target_skips_it_not_the_whole_run(self):
+        # regression: used to abort the whole run instead of skipping T2
+        t1 = _make_bioactivity_data()
+        n2 = 5
+        t2 = {
+            'connectivity': [f'D{i}' for i in range(n2)],
+            'target_id': ['T2'] * n2,
+            'Activity_class': [None] * n2,
+            'pchembl_value_Mean': [5.0, 5.2, 5.4, 7.0, 7.6],
+            'relation': ['='] * n2,
+            'Year': [2010] * n2,
+        }
+        data = pd.DataFrame({key: list(t1[key]) + t2[key] for key in t1})
+        descs = pl.LazyFrame({
+            'connectivity': _make_descriptors()['connectivity'] + t2['connectivity'],
+            'Desc_1': [i / (16 + n2) for i in range(16 + n2)],
+        })
+        with patch('src.papyrus_scripts.modelling.read_molecular_descriptors', return_value=descs):
+            results, models = qsar(data, model=DecisionTreeRegressor(random_state=0),
+                                   num_points=3, folds=5, split_by='random', verbose=False)
+        self.assertIn('Test set', results.loc['T1'].index)
+        self.assertIsNone(models['T2'])
+        self.assertIn('Not enough training data', results.loc['T2', 'error'].iloc[0])
+
 
 class TestModelMetricsMCC(unittest.TestCase):
     """Regression tests: model_metrics wrapped MCC computation in a

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/tests/test_neuralnet.py

@@ -185,6 +185,94 @@ class TestDefaultDevice(unittest.TestCase):
             self.assertEqual(nn_mod._default_device(), 'cpu')
 
 
+@unittest.skipUnless(TORCH_AVAILABLE, 'requires torch and skorch')
+class TestDeviceOverride(unittest.TestCase):
+    """Regression: passing device= used to collide with the hardcoded default."""
+
+    def test_explicit_device_kwarg_is_not_swallowed(self):
+        with tempfile.TemporaryDirectory() as d:
+            reg = SingleTaskNNRegressor(d, epochs=2, device='cpu')
+        self.assertEqual(reg.device, 'cpu')
+
+    def test_omitting_device_still_defaults_via_default_device(self):
+        with tempfile.TemporaryDirectory() as d:
+            reg = SingleTaskNNRegressor(d, epochs=2)
+        self.assertEqual(reg.device, nn_mod._default_device())
+
+    @unittest.skipIf(nn_mod.torch.cuda.is_available(), 'meaningful only when no GPU is present')
+    def test_requesting_cuda_when_unavailable_raises_at_fit(self):
+        # must fail loudly at fit(), not silently fall back to CPU
+        rng = _rng()
+        X, y = pd.DataFrame(rng.random((12, 4))), pd.Series(rng.random(12))
+        X_valid, y_valid = pd.DataFrame(rng.random((4, 4))), pd.Series(rng.random(4))
+        with tempfile.TemporaryDirectory() as d:
+            reg = SingleTaskNNRegressor(d, epochs=2, early_stop=2, hidden_layers=[4],
+                                        device='cuda', verbose=0)
+            reg.set_architecture(4)
+            reg.set_validation(X_valid, y_valid)
+            with self.assertRaises((RuntimeError, AssertionError)):
+                reg.fit(X, y)
+
+    @unittest.skipIf(nn_mod.torch.cuda.is_available(), 'meaningful only when no GPU is present')
+    def test_set_params_cuda_after_construction_raises_at_fit(self):
+        rng = _rng()
+        X, y = pd.DataFrame(rng.random((12, 4))), pd.Series(rng.random(12))
+        X_valid, y_valid = pd.DataFrame(rng.random((4, 4))), pd.Series(rng.random(4))
+        with tempfile.TemporaryDirectory() as d:
+            reg = SingleTaskNNRegressor(d, epochs=2, early_stop=2, hidden_layers=[4], verbose=0)
+            reg.set_params(device='cuda')
+            reg.set_architecture(4)
+            reg.set_validation(X_valid, y_valid)
+            with self.assertRaises((RuntimeError, AssertionError)):
+                reg.fit(X, y)
+
+
+@unittest.skipUnless(TORCH_AVAILABLE, 'requires torch and skorch')
+class TestBatchSize(unittest.TestCase):
+
+    def _fit(self, *, batch_size, n_train, tmpdir):
+        rng = _rng()
+        X = pd.DataFrame(rng.random((n_train, 4)))
+        y = pd.Series(rng.random(n_train))
+        X_valid = pd.DataFrame(rng.random((4, 4)))
+        y_valid = pd.Series(rng.random(4))
+        reg = SingleTaskNNRegressor(tmpdir, epochs=2, early_stop=2, hidden_layers=[4],
+                                    batch_size=batch_size, verbose=0)
+        reg.set_architecture(4)
+        reg.set_validation(X_valid, y_valid)
+        reg.fit(X, y)
+        return reg, X
+
+    def test_batch_size_of_one_does_not_raise(self):
+        with tempfile.TemporaryDirectory() as d:
+            reg, X = self._fit(batch_size=1, n_train=8, tmpdir=d)
+        self.assertEqual(reg.predict(X).shape, (8, 1))
+
+    def test_batch_size_larger_than_training_set_does_not_raise(self):
+        with tempfile.TemporaryDirectory() as d:
+            reg, X = self._fit(batch_size=1024, n_train=8, tmpdir=d)
+        self.assertEqual(reg.predict(X).shape, (8, 1))
+
+
+@unittest.skipUnless(TORCH_AVAILABLE, 'requires torch and skorch')
+class TestTinyTrainingSet(unittest.TestCase):
+
+    def test_two_training_and_two_validation_samples_does_not_raise(self):
+        rng = _rng()
+        X = pd.DataFrame(rng.random((2, 4)))
+        y = pd.Series(rng.random(2))
+        X_valid = pd.DataFrame(rng.random((2, 4)))
+        y_valid = pd.Series(rng.random(2))
+        with tempfile.TemporaryDirectory() as d:
+            reg = SingleTaskNNRegressor(d, epochs=2, early_stop=2, batch_size=1,
+                                        hidden_layers=[4], verbose=0)
+            reg.set_architecture(4)
+            reg.set_validation(X_valid, y_valid)
+            reg.fit(X, y)
+            preds = reg.predict(X)
+        self.assertEqual(preds.shape, (2, 1))
+
+
 @unittest.skipUnless(TORCH_AVAILABLE, 'requires torch and skorch')
 class TestSetSeed(unittest.TestCase):
 
@@ -386,5 +474,73 @@ class TestMultiTaskNN(unittest.TestCase):
                 reg.set_architecture(4, 1)
 
 
+@unittest.skipUnless(TORCH_AVAILABLE, 'requires torch and skorch')
+class TestMultiTaskMaskedLoss(unittest.TestCase):
+    """Multi-task data is rarely dense - NaN targets must be excluded from the loss, not crash it."""
+
+    def test_criterion_reduction_is_none(self):
+        # _MaskedMultiTaskLoss.get_loss needs an unreduced, per-element loss to mask.
+        with tempfile.TemporaryDirectory() as d:
+            reg = MultiTaskNNRegressor(d, epochs=2)
+            clf = MultiTaskNNClassifier(d, epochs=2)
+        self.assertEqual(reg.criterion__reduction, 'none')
+        self.assertEqual(clf.criterion__reduction, 'none')
+
+    def test_regressor_loss_ignores_nan_targets(self):
+        with tempfile.TemporaryDirectory() as d:
+            reg = MultiTaskNNRegressor(d, epochs=1)
+            reg.set_architecture(4, 3)
+            reg.initialize()
+            y_pred = nn_mod.torch.tensor([[1.0, 2.0, 3.0]])
+            y_true = nn_mod.torch.tensor([[1.0, float('nan'), 5.0]])
+            loss = reg.get_loss(y_pred, y_true.numpy())
+        # column 1 (NaN) excluded: mean((1-1)**2, (3-5)**2) = 2.0
+        self.assertAlmostEqual(loss.item(), 2.0, places=5)
+
+    def test_all_nan_batch_does_not_raise_or_produce_nan_loss(self):
+        with tempfile.TemporaryDirectory() as d:
+            reg = MultiTaskNNRegressor(d, epochs=1)
+            reg.set_architecture(4, 3)
+            reg.initialize()
+            y_pred = nn_mod.torch.zeros((2, 3))
+            y_true = nn_mod.torch.full((2, 3), float('nan'))
+            loss = reg.get_loss(y_pred, y_true.numpy())
+        self.assertEqual(loss.item(), 0.0)
+
+    def test_regressor_fits_with_sparse_targets(self):
+        rng = _rng()
+        X = pd.DataFrame(rng.random((40, 4)))
+        y = pd.DataFrame(rng.random((40, 3)))
+        y.iloc[::2, 1] = np.nan  # half of task 1's labels missing
+        X_valid = pd.DataFrame(rng.random((10, 4)))
+        y_valid = pd.DataFrame(rng.random((10, 3)))
+        y_valid.iloc[::3, 0] = np.nan
+        with tempfile.TemporaryDirectory() as d:
+            reg = MultiTaskNNRegressor(d, epochs=2, early_stop=2, lr=0.01, hidden_layers=[8, 4])
+            reg.set_architecture(4, 3)
+            reg.set_validation(X_valid, y_valid)
+            reg.fit(X, y)
+            preds = reg.predict(X)
+        self.assertEqual(preds.shape, (40, 3))
+        self.assertFalse(np.isnan(preds).any())
+
+    def test_classifier_fits_with_sparse_targets(self):
+        rng = _rng()
+        X = pd.DataFrame(rng.random((40, 4)))
+        y = pd.DataFrame(rng.integers(0, 2, (40, 3)).astype(float))
+        y.iloc[::2, 1] = np.nan
+        X_valid = pd.DataFrame(rng.random((10, 4)))
+        y_valid = pd.DataFrame(rng.integers(0, 2, (10, 3)).astype(float))
+        y_valid.iloc[::3, 0] = np.nan
+        with tempfile.TemporaryDirectory() as d:
+            clf = MultiTaskNNClassifier(d, epochs=2, early_stop=2, lr=0.01, hidden_layers=[8, 4])
+            clf.set_architecture(4, 3)
+            clf.set_validation(X_valid, y_valid)
+            clf.fit(X, y)
+            preds = clf.predict(X)
+        self.assertEqual(preds.shape, (40, 3))
+        self.assertTrue(set(np.unique(preds)).issubset({0.0, 1.0}))
+
+
 if __name__ == '__main__':
     unittest.main()

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/tests/test_oop.py

@@ -140,7 +140,8 @@ class TestPapyrusDataset(unittest.TestCase):
             ['Adenosine receptor'],
         )
         self.assertEqual(oop_data_agg['type_IC50'].cast(pl.Int64).unique().to_list(), [1])
-        oop_data_proteins = (PapyrusDataset.from_dataframe(oop_data_agg, self.stereo, self.version, self.plusplus)
+        oop_data_proteins = (PapyrusDataset.from_dataframe(oop_data_agg, self.stereo, self.version, self.plusplus,
+                                                            source_path=SOURCE_PATH)
                              .proteins(progress=True)
                              .to_dataframe(False))
         self.assertEqual(len(oop_data_agg['accession'].unique()), len(oop_data_proteins))
@@ -193,7 +194,8 @@ class TestPapyrusDataset(unittest.TestCase):
         )
         for accession in oop_data_agg['accession'].unique():
             self.assertNotIn(accession, ['P13500', 'P13501'])
-        oop_data_proteins = (PapyrusDataset.from_dataframe(oop_data_agg, self.stereo, self.version, self.plusplus)
+        oop_data_proteins = (PapyrusDataset.from_dataframe(oop_data_agg, self.stereo, self.version, self.plusplus,
+                                                            source_path=SOURCE_PATH)
                              .proteins(progress=True)
                              .to_dataframe(False))
         self.assertEqual(oop_data_proteins['Organism'].unique().to_list(), ['Mus musculus (Mouse)'])

{papyrus_scripts-3.0.1 → papyrus_scripts-3.0.2}/tests/test_oop_unit.py

@@ -545,6 +545,76 @@ class TestPapyrusDatasetDiskMargin(unittest.TestCase):
         self.assertEqual(mock_download.call_args.kwargs['disk_margin'], 0.25)
 
 
+class TestFromDataframeMissingProteinData(unittest.TestCase):
+    """from_dataframe must raise on missing protein data unless download_if_missing=True."""
+
+    def _df(self):
+        return pl.DataFrame({'connectivity': []})
+
+    def test_raises_by_default_on_missing_data(self):
+        with patch('src.papyrus_scripts.oop.reader.read_protein_set', side_effect=FileNotFoundError):
+            with self.assertRaises(FileNotFoundError):
+                PapyrusDataset.from_dataframe(df=self._df(), is3d=False, version='2022.04.2')
+
+    def test_does_not_download_by_default(self):
+        with (
+            patch('src.papyrus_scripts.oop.reader.read_protein_set', side_effect=FileNotFoundError),
+            patch('src.papyrus_scripts.oop.download.download_papyrus') as mock_download,
+        ):
+            with self.assertRaises(FileNotFoundError):
+                PapyrusDataset.from_dataframe(df=self._df(), is3d=False, version='2022.04.2')
+        mock_download.assert_not_called()
+
+    def test_download_if_missing_downloads_and_retries(self):
+        with (
+            patch(
+                'src.papyrus_scripts.oop.reader.read_protein_set',
+                side_effect=[FileNotFoundError, pl.DataFrame()],
+            ),
+            patch('src.papyrus_scripts.oop.download.download_papyrus') as mock_download,
+        ):
+            dataset = PapyrusDataset.from_dataframe(
+                df=self._df(), is3d=False, version='2022.04.2', download_if_missing=True,
+            )
+        mock_download.assert_called_once()
+        self.assertIsInstance(dataset.papyrus_protein_data, pl.DataFrame)
+
+    def test_download_if_missing_uses_pystow_path_key_and_forwards_params(self):
+        with (
+            patch(
+                'src.papyrus_scripts.oop.reader.read_protein_set',
+                side_effect=[FileNotFoundError, pl.DataFrame()],
+            ),
+            patch('src.papyrus_scripts.oop.download.download_papyrus') as mock_download,
+        ):
+            PapyrusDataset.from_dataframe(
+                df=self._df(), is3d=True, version='2022.04.2', plusplus=False,
+                source_path='/tmp/somewhere', download_progress=False,  # noqa: S108
+                keep_original_files=True, disk_margin=0.25, download_if_missing=True,
+            )
+        kwargs = mock_download.call_args.kwargs
+        self.assertEqual(kwargs['version'], '2022.04.2')
+        self.assertEqual(kwargs['outdir'], '/tmp/somewhere')  # noqa: S108
+        self.assertTrue(kwargs['stereo'])
+        self.assertFalse(kwargs['nostereo'])
+        self.assertFalse(kwargs['only_pp'])
+        self.assertFalse(kwargs['structures'])
+        self.assertIsNone(kwargs['descriptors'])
+        self.assertFalse(kwargs['progress'])
+        self.assertTrue(kwargs['keep_xz'])
+        self.assertEqual(kwargs['disk_margin'], 0.25)
+
+    def test_does_not_download_when_data_is_present(self):
+        with (
+            patch('src.papyrus_scripts.oop.reader.read_protein_set', return_value=pl.DataFrame()),
+            patch('src.papyrus_scripts.oop.download.download_papyrus') as mock_download,
+        ):
+            PapyrusDataset.from_dataframe(
+                df=self._df(), is3d=False, version='2022.04.2', download_if_missing=True,
+            )
+        mock_download.assert_not_called()
+
+
 class TestProteinDescriptorsCustomPath(unittest.TestCase):
     """protein_descriptors('custom', ...) must accept a custom_descriptor_path
     and forward it as source_path, without attempting the Papyrus