bonesistools 1.2.4__tar.gz → 1.2.5__tar.gz

{bonesistools-1.2.4 → bonesistools-1.2.5}/.gitignore

@@ -111,6 +111,7 @@ src/bonesistools/databases/omnipath/.cache/
 !tests/data/
 !tests/data/*.h5ad
 tests/dbs/data/*.json
+tests/reproducibility/*.json
 !src/bonesistools/sctools/datasets/
 !src/bonesistools/sctools/datasets/*.h5ad
 scripts/

{bonesistools-1.2.4 → bonesistools-1.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bonesistools
-Version: 1.2.4
+Version: 1.2.5
 Summary: Bioinformatics toolkit for upstream and downstream analyses around the BoNesis framework
 Project-URL: Repository, https://github.com/bnediction/bonesistools
 Author: Théo Roncalli
@@ -556,16 +556,19 @@ Requires-Dist: matplotlib>=3.5
 Requires-Dist: networkx>=2.1
 Requires-Dist: numpy>=1.21
 Requires-Dist: pandas>=1.3.5
+Requires-Dist: scikit-learn>=1.0
 Requires-Dist: scipy>=1.7
 Requires-Dist: typing-extensions>=4.0
 Provides-Extra: all
 Requires-Dist: graphviz>=0.20; extra == 'all'
+Requires-Dist: igraph>=0.10; extra == 'all'
+Requires-Dist: leidenalg>=0.10; extra == 'all'
 Requires-Dist: mpbn>=4.1; extra == 'all'
 Requires-Dist: mudata>=0.3.1; extra == 'all'
 Requires-Dist: multiprocess>=0.70.18; extra == 'all'
 Requires-Dist: pydot>=3.0.2; extra == 'all'
-Requires-Dist: scikit-learn>=1.0; extra == 'all'
 Requires-Dist: seaborn>=0.11; extra == 'all'
+Requires-Dist: umap-learn>=0.5; extra == 'all'
 Provides-Extra: graphviz
 Requires-Dist: graphviz>=0.20; extra == 'graphviz'
 Provides-Extra: mpbn
@@ -573,7 +576,9 @@ Requires-Dist: mpbn>=4.1; extra == 'mpbn'
 Provides-Extra: mudata
 Requires-Dist: mudata>=0.3.1; extra == 'mudata'
 Provides-Extra: sctools
-Requires-Dist: scikit-learn>=1.0; extra == 'sctools'
+Requires-Dist: igraph>=0.10; extra == 'sctools'
+Requires-Dist: leidenalg>=0.10; extra == 'sctools'
+Requires-Dist: umap-learn>=0.5; extra == 'sctools'
 Description-Content-Type: text/markdown
 
 [![tests](https://github.com/bnediction/bonesistools/actions/workflows/tests.yml/badge.svg)](https://github.com/bnediction/bonesistools/actions/workflows/tests.yml)
@@ -611,7 +616,7 @@ import bonesistools as bt
 
 ## Single-cell tools
 
-`bt.sct` follows a [Scanpy](https://github.com/scverse/scanpy)-like API while providing additional and complementary features for single-cell analyses.
+`bt.sct` is inspired by [Scanpy](https://github.com/scverse/scanpy) while providing additional and complementary features for single-cell analyses.
 
 Submodules:
 

{bonesistools-1.2.4 → bonesistools-1.2.5}/README.md

@@ -33,7 +33,7 @@ import bonesistools as bt
 
 ## Single-cell tools
 
-`bt.sct` follows a [Scanpy](https://github.com/scverse/scanpy)-like API while providing additional and complementary features for single-cell analyses.
+`bt.sct` is inspired by [Scanpy](https://github.com/scverse/scanpy) while providing additional and complementary features for single-cell analyses.
 
 Submodules:
 

{bonesistools-1.2.4 → bonesistools-1.2.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "hatchling.build"
 [project]
 name = "bonesistools"
 description = "Bioinformatics toolkit for upstream and downstream analyses around the BoNesis framework"
-version = "1.2.4"
+version = "1.2.5"
 license = {file = "LICENSE"}
 credits = ["BNeDiction", "PEPR Santé Numérique 2030"]
 authors = [
@@ -46,6 +46,7 @@ dependencies = [
     "numpy>=1.21",
     "pandas>=1.3.5",
     "scipy>=1.7",
+    "scikit-learn>=1.0",
     "networkx>=2.1",
     "matplotlib>=3.5",
     "h5py>=3.7",
@@ -71,14 +72,20 @@ all = [
     "mudata>=0.3.1",
     "multiprocess>=0.70.18",
     "pydot>=3.0.2",
-    "scikit-learn>=1.0",
+    "igraph>=0.10",
+    "leidenalg>=0.10",
     "seaborn>=0.11",
+    "umap-learn>=0.5",
     "mpbn>=4.1",
 ]
 graphviz = [ "graphviz>=0.20" ]
 mudata = [ "mudata>=0.3.1" ]
 mpbn = [ "mpbn>=4.1" ]
-sctools = [ "scikit-learn>=1.0" ]
+sctools = [
+    "igraph>=0.10",
+    "leidenalg>=0.10",
+    "umap-learn>=0.5",
+]
 
 [tool.hatch.build.targets.sdist]
 ignore-vcs = true
@@ -113,6 +120,9 @@ select = ["E", "F", "I"]
 typing-modules = ["bonesistools._compat"]
 
 [tool.pytest.ini_options]
+norecursedirs = [
+    "tests/reproducibility",
+]
 filterwarnings = [
     "ignore:The NumPy module was reloaded:UserWarning",
 ]

{bonesistools-1.2.4 → bonesistools-1.2.5}/src/bonesistools/__init__.py

@@ -22,7 +22,6 @@ from __future__ import annotations
 
 import importlib as _importlib
 import sys as _sys
-import warnings as _warnings
 from types import ModuleType as _ModuleType
 from typing import TYPE_CHECKING as _TYPE_CHECKING
 from typing import List as _List
@@ -30,6 +29,7 @@ from typing import List as _List
 from . import boolpy as bpy
 from . import databases as dbs
 from . import sctools as sct
+from ._warnings import _warn_deprecated
 
 if _TYPE_CHECKING:
     from . import grntools as grn
@@ -66,13 +66,9 @@ _sys.modules.update(
 
 def __getattr__(name: str) -> _ModuleType:
     if name == "grn":
-        message = (
-            "`bt.grn` is deprecated and will be removed in a future release; "
-            "use `bt.bpy.ig` instead."
-        )
-        _warnings.warn(
-            message,
-            FutureWarning,
+        _warn_deprecated(
+            "`bt.grn`",
+            replacement="`bt.bpy.ig`",
             stacklevel=2,
         )
 

bonesistools-1.2.5/src/bonesistools/_typing.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python
+
+from types import ModuleType
+from typing import Optional, Union
+
+import numpy as np
+
+from ._compat import Literal
+
+RandomStateSeed = Optional[Union[int, np.random.RandomState, ModuleType]]
+AutoInteger = Union[int, Literal["auto"]]
+DataFrameAxis = Literal["index", "columns"]
+FileOrientation = Literal["rows", "columns"]

bonesistools-1.2.5/src/bonesistools/_validation.py

@@ -0,0 +1,388 @@
+#!/usr/bin/env python
+
+import numbers
+import re
+from typing import Callable, Iterable, Optional, TypeVar, Union, overload
+
+import numpy as np
+
+from ._compat import Literal
+from ._typing import (
+    DataFrameAxis,
+    FileOrientation,
+    RandomStateSeed,
+)
+
+T = TypeVar("T", bound=str)
+F = TypeVar("F", bound=Callable[..., object])
+
+_MEMORY_SIZE_PATTERN = re.compile(
+    r"^\s*(?P<value>[0-9]+(?:\.[0-9]+)?)\s*(?P<unit>[KMGT]i?B)\s*$",
+    re.IGNORECASE,
+)
+_MEMORY_SIZE_UNITS = {
+    "KB": 10**3,
+    "MB": 10**6,
+    "GB": 10**9,
+    "TB": 10**12,
+    "KIB": 2**10,
+    "MIB": 2**20,
+    "GIB": 2**30,
+    "TIB": 2**40,
+}
+
+
+def _format_choices(choices: Iterable[str], *, include_none: bool = False) -> str:
+
+    choices = tuple(choices)
+    formatted = tuple(repr(choice) for choice in choices)
+    if include_none:
+        formatted = formatted + ("None",)
+    if len(formatted) == 1:
+        return formatted[0]
+    if len(formatted) == 2:
+        return f"{formatted[0]} or {formatted[1]}"
+    return f"{', '.join(formatted[:-1])} or {formatted[-1]}"
+
+
+@overload
+def _as_literal(
+    value: str,
+    *,
+    choices: Iterable[T],
+    name: str,
+    allow_none: Literal[False] = False,
+) -> T: ...
+
+
+@overload
+def _as_literal(
+    value: Optional[str],
+    *,
+    choices: Iterable[T],
+    name: str,
+    allow_none: Literal[True],
+) -> Optional[T]: ...
+
+
+def _as_literal(
+    value: Optional[str],
+    *,
+    choices: Iterable[T],
+    name: str,
+    allow_none: bool = False,
+) -> Optional[T]:
+
+    if value is None and allow_none:
+        return None
+
+    if not isinstance(value, str):
+        expected = f"{str} or None" if allow_none else str
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {expected} but received {type(value)}"
+        )
+
+    resolved_choices = tuple(choices)
+    for choice in resolved_choices:
+        if value == choice:
+            return choice
+
+    expected = _format_choices(resolved_choices, include_none=allow_none)
+    raise ValueError(
+        f"invalid argument value for '{name}': "
+        f"expected one of {expected} but received {value!r}"
+    )
+
+
+@overload
+def _as_string(
+    value: str,
+    name: str,
+    *,
+    allow_none: Literal[False] = False,
+) -> str: ...
+
+
+@overload
+def _as_string(
+    value: Optional[str],
+    name: str,
+    *,
+    allow_none: Literal[True],
+) -> Optional[str]: ...
+
+
+def _as_string(
+    value: Optional[str],
+    name: str,
+    *,
+    allow_none: bool = False,
+) -> Optional[str]:
+
+    if value is None and allow_none:
+        return None
+
+    if not isinstance(value, str):
+        expected = f"{str} or None" if allow_none else str
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {expected} but received {type(value)}"
+        )
+
+    return value
+
+
+@overload
+def _as_boolean(
+    value: bool,
+    name: str,
+    *,
+    allow_none: Literal[False] = False,
+) -> bool: ...
+
+
+@overload
+def _as_boolean(
+    value: Optional[bool],
+    name: str,
+    *,
+    allow_none: Literal[True],
+) -> Optional[bool]: ...
+
+
+def _as_boolean(
+    value: Optional[bool],
+    name: str,
+    *,
+    allow_none: bool = False,
+) -> Optional[bool]:
+
+    if value is None and allow_none:
+        return None
+
+    if not isinstance(value, bool):
+        expected = f"{bool} or None" if allow_none else bool
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {expected} but received {type(value)}"
+        )
+
+    return value
+
+
+@overload
+def _as_callable(
+    value: F,
+    name: str,
+    *,
+    allow_none: Literal[False] = False,
+) -> F: ...
+
+
+@overload
+def _as_callable(
+    value: Optional[F],
+    name: str,
+    *,
+    allow_none: Literal[True],
+) -> Optional[F]: ...
+
+
+def _as_callable(
+    value: Optional[F],
+    name: str,
+    *,
+    allow_none: bool = False,
+) -> Optional[F]:
+
+    if value is None and allow_none:
+        return None
+
+    if not callable(value):
+        expected = "callable object or None" if allow_none else "callable object"
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {expected} but received {type(value)}"
+        )
+
+    return value
+
+
+def _as_positive_number(value: float, name: str) -> float:
+
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {float} but received {type(value)}"
+        )
+
+    value = float(value)
+    if value <= 0:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected positive value but received {value!r}"
+        )
+
+    return value
+
+
+def _as_non_negative_number(value: float, name: str) -> float:
+
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {float} but received {type(value)}"
+        )
+
+    value = float(value)
+    if value < 0:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected non-negative value but received {value!r}"
+        )
+
+    return value
+
+
+def _as_positive_integer(value: Union[int, float], name: str) -> int:
+
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {int} but received {type(value)}"
+        )
+
+    if value <= 0:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected non-null positive value but received {value!r}"
+        )
+
+    if isinstance(value, float) and not value.is_integer():
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected integer but received {value!r}"
+        )
+
+    return int(value)
+
+
+def _as_non_negative_integer(value: Union[int, float], name: str) -> int:
+
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {int} but received {type(value)}"
+        )
+
+    if value < 0:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected non-negative value but received {value!r}"
+        )
+
+    if isinstance(value, float) and not value.is_integer():
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected integer but received {value!r}"
+        )
+
+    return int(value)
+
+
+def _as_memory_size(value: Union[int, str], name: str) -> int:
+
+    if isinstance(value, bool) or not isinstance(value, (int, str)):
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {int} or {str} but received {type(value)}"
+        )
+
+    if isinstance(value, int):
+        if value <= 0:
+            raise ValueError(
+                f"invalid argument value for '{name}': "
+                f"expected positive memory size but received {value!r}"
+            )
+        return value
+
+    match = _MEMORY_SIZE_PATTERN.match(value)
+    if match is None:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            "expected memory size with unit KB, MB, GB, TB, KiB, MiB, GiB or TiB "
+            f"but received {value!r}"
+        )
+
+    size = float(match.group("value"))
+    unit = match.group("unit").upper()
+    bytes_size = int(size * _MEMORY_SIZE_UNITS[unit])
+    if bytes_size <= 0:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected positive memory size but received {value!r}"
+        )
+
+    return bytes_size
+
+
+def _as_probability(value: float, name: str) -> float:
+
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise TypeError(
+            f"unsupported argument type for '{name}': "
+            f"expected {float} but received {type(value)}"
+        )
+
+    value = float(value)
+    if not 0 <= value <= 1:
+        raise ValueError(
+            f"invalid argument value for '{name}': "
+            f"expected value between 0 and 1 but received {value!r}"
+        )
+
+    return value
+
+
+def _as_seed(seed: RandomStateSeed) -> np.random.RandomState:
+
+    if seed is None or seed is np.random:
+        return np.random.mtrand._rand
+    if isinstance(seed, numbers.Integral):
+        return np.random.RandomState(int(seed))
+    if isinstance(seed, np.random.RandomState):
+        return seed
+    raise ValueError(
+        f"invalid argument value for 'seed': "
+        f"expected None, np.random, integer seed or np.random.RandomState "
+        f"but received {seed!r}"
+    )
+
+
+def _as_dataframe_axis(axis: Union[int, str]) -> DataFrameAxis:
+
+    if isinstance(axis, str) and axis == "index":
+        return "index"
+    if isinstance(axis, str) and axis == "columns":
+        return "columns"
+    if isinstance(axis, int) and not isinstance(axis, bool) and axis == 0:
+        return "index"
+    if isinstance(axis, int) and not isinstance(axis, bool) and axis == 1:
+        return "columns"
+
+    raise ValueError(
+        f"invalid argument value for 'axis': "
+        f"expected 0, 1, 'index' or 'columns' but received {axis!r}"
+    )
+
+
+def _as_orientation(orientation: str) -> FileOrientation:
+
+    if orientation == "rows" or orientation == "columns":
+        return orientation
+
+    raise ValueError(
+        f"invalid argument value for 'orientation': "
+        f"expected 'rows' or 'columns' but received {orientation!r}"
+    )

bonesistools-1.2.5/src/bonesistools/_warnings.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python
+
+import warnings
+from typing import Optional
+
+
+def _warn_deprecated(
+    name: str,
+    *,
+    replacement: Optional[str] = None,
+    stacklevel: int = 2,
+) -> None:
+
+    message = f"{name} is deprecated and will be removed in 2.0.0"
+    if replacement is not None:
+        message = f"{message}; use {replacement} instead"
+    warnings.warn(f"{message}.", FutureWarning, stacklevel=stacklevel)
+
+
+def _warn_deprecated_argument(
+    old_name: str,
+    new_name: str,
+    *,
+    stacklevel: int = 2,
+) -> None:
+
+    _warn_deprecated(
+        f"`{old_name}`",
+        replacement=f"`{new_name}`",
+        stacklevel=stacklevel,
+    )

{bonesistools-1.2.4 → bonesistools-1.2.5}/src/bonesistools/boolpy/__init__.py

@@ -21,13 +21,13 @@ pl
 from __future__ import annotations
 
 import sys as _sys
-import warnings as _warnings
 from types import ModuleType as _ModuleType
 from typing import Dict as _Dict
 from typing import List as _List
 from typing import Tuple as _Tuple
 from typing import cast as _cast
 
+from .._warnings import _warn_deprecated
 from . import boolean_algebra as ba
 from . import boolean_network as bn
 from . import influence_graph as ig
@@ -65,10 +65,9 @@ __all__ = [
 def __getattr__(name: str) -> object:
     if name in _DEPRECATED:
         module_alias, attr = _DEPRECATED[name]
-        _warnings.warn(
-            f"`bt.bpy.{name}` is deprecated; use "
-            f"`bt.bpy.{module_alias}.{attr}` instead.",
-            DeprecationWarning,
+        _warn_deprecated(
+            f"`bt.bpy.{name}`",
+            replacement=f"`bt.bpy.{module_alias}.{attr}`",
             stacklevel=2,
         )
         return _cast(object, getattr(_MODULES[module_alias], attr))

{bonesistools-1.2.4 → bonesistools-1.2.5}/src/bonesistools/boolpy/boolean_algebra/_algebra.py

@@ -407,6 +407,7 @@ class BooleanPredecessorInference:
 
     @staticmethod
     def _coerce_value(value: PartialBooleanLike) -> PartialBoolean:
+
         return PartialBooleanDifferential._coerce_value(value)
 
     @staticmethod

{bonesistools-1.2.4 → bonesistools-1.2.5}/src/bonesistools/boolpy/boolean_algebra/_hypercube.py

@@ -8,13 +8,16 @@ from collections.abc import (
     Mapping,
 )
 from typing import (
+    Any,
     Dict,
     FrozenSet,
     MutableMapping,
     MutableSet,
     Optional,
     Set,
+    Tuple,
     cast,
+    overload,
 )
 
 from ._boolean import PartialBoolean
@@ -169,6 +172,44 @@ class Hypercube(MutableMapping[str, PartialBoolean]):
 
         return len(self._values)
 
+    @overload
+    def update(self, mapping: Mapping[str, PartialBooleanLike]) -> None: ...
+
+    @overload
+    def update(self, mapping: Iterable[Tuple[str, PartialBooleanLike]]) -> None: ...
+
+    @overload
+    def update(self, **kwargs: PartialBooleanLike) -> None: ...
+
+    def update(  # pyright: ignore[reportIncompatibleMethodOverride]
+        self,
+        *args: Any,
+        **kwargs: PartialBooleanLike,
+    ) -> None:
+        """
+        Update explicitly specified component values.
+
+        Values are converted to `PartialBoolean`, following `__setitem__`.
+        """
+
+        if len(args) > 1:
+            raise TypeError(
+                f"update expected at most 1 positional argument, got {len(args)}"
+            )
+
+        if args:
+            other = args[0]
+            if isinstance(other, Mapping):
+                iterable = other.items()
+            else:
+                iterable = other
+
+            for component, value in iterable:
+                self[component] = value
+
+        for component, value in kwargs.items():
+            self[component] = value
+
     def __repr__(self) -> str:
         """
         Return a representation of the hypercube.