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

{papyrus_scripts-3.0.0/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.0
+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.0 → 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.0 → 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.0'
+__version__ = '3.0.2'

{papyrus_scripts-3.0.0 → papyrus_scripts-3.0.2}/src/papyrus_scripts/download.py

@@ -83,17 +83,29 @@ _SIZE_KEY_BY_FTYPE = {
     '3D_structures':   'structures_3D',
 }
 
-def _size_for_ftype(sizes: dict, ftype: str) -> int | None:
+#: data_size.json omits 'prodec' on every 2022.11.x release (.1-.4), even
+#: though the file itself is published. All four share one sha256; row
+#: count independently verified via ``xz -dc <file> | wc -l``.
+_ROW_COUNT_OVERRIDE_BY_SHA256: dict[str, int] = {
+    '3211a62f18ccb7ccc13f885374c1462efeb83ab0e98ed62d2645723f7dc9f1a1': 7505,
+}
+
+
+def _size_for_ftype(sizes: dict, ftype: str, sha256: str | None = None) -> int | None:
     """Look up *ftype*'s row count in a parsed data_size.json, or ``None`` if absent.
 
     Releases up to 2022.11.4 key papyrus++ as ``"papyrus++"``; 2024.09.1+
     use ``"papyrus_++"`` (``_SIZE_KEY_BY_FTYPE['papyrus++']``) - try both.
+
+    :param sha256: fallback key into :data:`_ROW_COUNT_OVERRIDE_BY_SHA256`.
     """
     key = _SIZE_KEY_BY_FTYPE.get(ftype)
     if key in sizes:
         return sizes[key]
     if ftype == 'papyrus++' and 'papyrus++' in sizes:
         return sizes['papyrus++']
+    if sha256 is not None and sha256 in _ROW_COUNT_OVERRIDE_BY_SHA256:
+        return _ROW_COUNT_OVERRIDE_BY_SHA256[sha256]
     return None
 
 
@@ -807,7 +819,11 @@ def download_papyrus(outdir: str | Path | None = None,
                     _update_current_file_description()
 
         def _wait_for_converter() -> None:
-            """Block until the converter process exits, draining progress messages meanwhile."""
+            """Block until the converter process exits, draining progress messages meanwhile.
+
+            Does not close converting_pbar - callers do that via
+            _close_converting_pbar, once success/failure is known.
+            """
             # Only ever called once converter_process has been started (see call sites).
             if converter_process is None:  # noqa: B023
                 raise RuntimeError('converter_process not started')
@@ -815,8 +831,27 @@ def download_papyrus(outdir: str | Path | None = None,
                 _drain_progress_queue()
                 converter_process.join(timeout=0.1)  # noqa: B023
             _drain_progress_queue()
-            if converting_pbar is not None:  # noqa: B023
-                converting_pbar.close()  # noqa: B023
+
+        def _close_converting_pbar(success: bool) -> None:
+            """Close converting_pbar, topping it up to 100% first on success.
+
+            total is a naive line count that can exceed the true row count
+            (see convert_xz_to_parquet's docstring), so n often lands just
+            under total even on success - tqdm.notebook then marks the bar
+            'danger' (red) as if it had failed. Topping up avoids that;
+            skipped on failure, where n < total is a real signal.
+            """
+            if converting_pbar is None:  # noqa: B023
+                return
+            if (
+                success  # noqa: B023
+                and isinstance(converting_pbar.total, (int, float))  # noqa: B023
+                and isinstance(converting_pbar.n, (int, float))  # noqa: B023
+            ):
+                shortfall = converting_pbar.total - converting_pbar.n  # noqa: B023
+                if shortfall > 0:
+                    converting_pbar.update(shortfall)  # noqa: B023
+            converting_pbar.close()  # noqa: B023
 
         def _enqueue(item) -> None:
             """Put *item* on task_queue, staying responsive while backpressured.
@@ -850,15 +885,16 @@ def download_papyrus(outdir: str | Path | None = None,
                     _drain_progress_queue()
 
         if not keep_xz:
-            # ftype per file still needing conversion; used once data_size.json
-            # is read to compute converting_pbar's total row count.
-            to_convert_ftypes: list[str] = []
+            # (ftype, sha256) per file still needing conversion, for
+            # converting_pbar's total - sha256 lets _size_for_ftype fall
+            # back to _ROW_COUNT_OVERRIDE_BY_SHA256 if needed.
+            to_convert_ftypes: list[tuple[str, str]] = []
             for ftype in ordered_ftypes:
                 for entry in _iter_entries(version_files[ftype]):
                     fpath = _file_path(papyrus_version_root, ftype, entry['name'])
                     parquet_path = _parquet_sibling(fpath)
                     if parquet_path is not None and not parquet_path.is_file():
-                        to_convert_ftypes.append(ftype)
+                        to_convert_ftypes.append((ftype, entry['sha256']))
 
             task_queue = mp.Queue(maxsize=1)
             error_queue = mp.Queue()
@@ -972,8 +1008,8 @@ def download_papyrus(outdir: str | Path | None = None,
                                 # unless any is unknown (avoid understating it).
                                 if progress and converting_pbar is not None and to_convert_ftypes:
                                     per_file_rows = [
-                                        _size_for_ftype(sizes, ft)
-                                        for ft in to_convert_ftypes
+                                        _size_for_ftype(sizes, ft, sha)
+                                        for ft, sha in to_convert_ftypes
                                     ]
                                     if all(n is not None for n in per_file_rows):
                                         # reset() syncs the widget's max too, unlike plain `.total =`.
@@ -985,7 +1021,7 @@ def download_papyrus(outdir: str | Path | None = None,
                             'parquet_path': parquet_path,
                             'schema_overrides': schemas.get(_SCHEMA_KEY_BY_FTYPE.get(ftype)),
                             'null_values': _NULL_VALUES_BY_FTYPE.get(ftype),
-                            'total_rows': _size_for_ftype(sizes, ftype),
+                            'total_rows': _size_for_ftype(sizes, ftype, dhash),
                             # ftype (e.g. 'papyrus++', '2D_mold2') rather
                             # than fpath.name: the real filenames (e.g.
                             # '05.6++_combined_set_without_stereochemistry
@@ -1012,6 +1048,7 @@ def download_papyrus(outdir: str | Path | None = None,
                     raise RuntimeError('task_queue not created') from None
                 _enqueue(_CONVERSION_DONE)
                 _wait_for_converter()
+                _close_converting_pbar(success=False)
             if progress:
                 pbar.close()
             raise
@@ -1028,6 +1065,7 @@ def download_papyrus(outdir: str | Path | None = None,
             _enqueue(_CONVERSION_DONE)
             _wait_for_converter()
             error = error_queue.get()
+            _close_converting_pbar(success=error is None)
             if error is not None:
                 if progress:
                     pbar.close()

{papyrus_scripts-3.0.0 → 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.0 → 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.0 → 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.0 → 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.0 → papyrus_scripts-3.0.2}/src/papyrus_scripts/preprocess.py

@@ -290,7 +290,9 @@ def process_groups(
 
     if has_pchembl:
         pv     = pl.col('pchembl_value')
-        pv_num = pv.cast(pl.Float64)
+        # Raw values can carry padding (e.g. "  6.700") - strip before the
+        # strict numeric cast, which otherwise rejects it.
+        pv_num = pv.str.strip_chars().cast(pl.Float64)
         median = pv_num.median()
         n      = pv_num.drop_nulls().len()
         std    = pv_num.std()

{papyrus_scripts-3.0.0 → 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,16 +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.FPSim2Cuda import FPSim2CudaEngine  # pragma: no cover
-    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
@@ -60,12 +62,18 @@ except ImportError:
 
     class FPSim2Engine:  # type: ignore[no-redef]
         """Stub for FPSim2.FPSim2.FPSim2Engine when FPSim2 is absent."""
+    BATCH_WRITE_SIZE = 32_000  # FPSim2's own default; only used for queue sizing here
 
+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.
+    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 FPSim2 is absent."""
-    BATCH_WRITE_SIZE = 32_000  # FPSim2's own default; only used for queue sizing here
+        """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.0 → 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():