bonesistools 1.2.4__tar.gz → 1.2.6__tar.gz

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

@@ -62,6 +62,7 @@ Thumbs.db
 /tmp/
 /temp/
 *.tmp
+*tmp*
 *.bak
 *.bak.tsv
 
@@ -111,6 +112,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.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bonesistools
-Version: 1.2.4
+Version: 1.2.6
 Summary: Bioinformatics toolkit for upstream and downstream analyses around the BoNesis framework
 Project-URL: Repository, https://github.com/bnediction/bonesistools
 Author: Théo Roncalli
@@ -551,21 +551,25 @@ Requires-Python: >=3.7
 Requires-Dist: anndata>=0.8
 Requires-Dist: boolean-py>=4.0
 Requires-Dist: h5py>=3.7
+Requires-Dist: importlib-metadata; python_version < '3.8'
 Requires-Dist: importlib-resources; python_version < '3.9'
 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 +577,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 +617,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.6}/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.6}/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.6"
 license = {file = "LICENSE"}
 credits = ["BNeDiction", "PEPR Santé Numérique 2030"]
 authors = [
@@ -41,11 +41,13 @@ classifiers = [
 ]
 requires-python = ">=3.7"
 dependencies = [
+    "importlib-metadata; python_version < '3.8'",
     "importlib_resources; python_version < '3.9'",
     "typing-extensions>=4.0",
     "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 +73,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 +121,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.6}/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,8 @@ from typing import List as _List
 from . import boolpy as bpy
 from . import databases as dbs
 from . import sctools as sct
+from ._metadata import package_version as _package_version
+from ._warnings import _warn_deprecated
 
 if _TYPE_CHECKING:
     from . import grntools as grn
@@ -37,8 +38,10 @@ if _TYPE_CHECKING:
 del annotations
 
 __credits__ = "BNeDiction; PEPR Santé Numérique 2030"
+__version__ = _package_version()
 
 __all__ = [
+    "__version__",
     "sct",
     "bpy",
     "dbs",
@@ -66,13 +69,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.6/src/bonesistools/_metadata.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python
+
+from __future__ import annotations
+
+import importlib
+from pathlib import Path
+from typing import Any, Optional, cast
+
+
+def package_version(distribution: str = "bonesistools") -> str:
+    """
+    Return the installed package version.
+
+    When the package is imported directly from a source checkout, distribution
+    metadata can be unavailable. In that case, read the version from
+    `pyproject.toml`.
+    """
+
+    source_version = _pyproject_version()
+    if source_version is not None:
+        return source_version
+
+    installed_version = _installed_version(distribution)
+    return installed_version if installed_version is not None else "0+unknown"
+
+
+def _installed_version(distribution: str) -> Optional[str]:
+
+    try:
+        metadata = importlib.import_module("importlib.metadata")
+    except ImportError:  # pragma: no cover - Python 3.7 compatibility
+        metadata = importlib.import_module("importlib_metadata")
+
+    try:
+        return cast(str, cast(Any, metadata).version(distribution))
+    except Exception as error:
+        if error.__class__.__name__ == "PackageNotFoundError":
+            return None
+        raise
+
+
+def _pyproject_version() -> Optional[str]:
+
+    pyproject = _find_pyproject()
+    if pyproject is None:
+        return None
+
+    in_project = False
+    for line in pyproject.read_text(encoding="utf-8").splitlines():
+        stripped = line.strip()
+        if stripped == "[project]":
+            in_project = True
+            continue
+        if in_project and stripped.startswith("["):
+            return None
+        if in_project and stripped.startswith("version"):
+            _, value = stripped.split("=", 1)
+            return value.strip().strip("\"'")
+
+    return None
+
+
+def _find_pyproject() -> Optional[Path]:
+
+    for parent in Path(__file__).resolve().parents:
+        pyproject = parent / "pyproject.toml"
+        if pyproject.exists():
+            return pyproject
+
+    return None

bonesistools-1.2.6/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.6/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.6/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,
+    )