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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: papyrus_scripts
-Version: 3.0.0
+Version: 3.0.1
 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>

{papyrus_scripts-3.0.0 → papyrus_scripts-3.0.1}/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.1'

{papyrus_scripts-3.0.0 → papyrus_scripts-3.0.1}/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.1}/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', 'horizontal_extend', 'align', 'align_full', 'align_inner',
+    'horizontal', 'align', 'align_full', 'align_inner',
     'align_left', 'align_right',
 ]
 
@@ -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()
@@ -734,7 +736,10 @@ def keep_protein_class(
         return data.filter(pl.lit(False))
 
     # level_frames always share len(protein_data) rows, so this never pads.
-    split_classes = pl.concat(level_frames, how='horizontal_extend')
+    # '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')
 
     # Build the boolean mask over protein rows.
     mask = pl.Series([False] * len(split_classes))

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

@@ -38,7 +38,6 @@ try:
     # 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,
@@ -60,10 +59,16 @@ 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.
+    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