bblean 0.6.0b2__cp312-cp312-win_amd64.whl

bblean/similarity.py

@@ -0,0 +1,304 @@
+"""Optimized molecular similarity calculators"""
+
+import os
+import warnings
+
+from numpy.typing import NDArray
+import numpy as np
+
+# NOTE: The most expensive calculation is *jt_sim_packed*, followed by _popcount_2d,
+# centroid_from_sum, packing and unpacking
+# TODO: Packing and unpacking *should be done in C++ using a lookup table*
+__all__ = [
+    # JT sim between two (sets of) fingerprints, and average tanimoto (using iSIM)
+    "jt_isim_from_sum",
+    "jt_isim",
+    "jt_sim_packed",
+    "jt_most_dissimilar_packed",
+    # Radius and diameter from sum
+    "jt_isim_radius_from_sum",
+    "jt_isim_radius_compl_from_sum",
+    "jt_isim_diameter_from_sum",
+    # Radius and diameter from fps (packed and unpacked)
+    "jt_isim_radius",
+    "jt_isim_radius_compl",
+    "jt_isim_diameter",
+    # Centroid and medoid
+    # Radius and diameter unpacked / packed
+    "centroid_from_sum",
+    "centroid",
+    "jt_isim_medoid",
+    # Complementary similarity
+    "jt_compl_isim",
+    "jt_stratified_sampling",
+    "jt_sim_matrix_packed",
+]
+
+from bblean._py_similarity import (
+    centroid_from_sum,
+    centroid,
+    jt_compl_isim,
+    jt_isim_medoid,
+)
+
+# jt_isim_packed and jt_isim_unpacked are not exposed, only used within functions for
+# speed
+
+if os.getenv("BITBIRCH_NO_EXTENSIONS"):
+    from bblean._py_similarity import (
+        jt_isim_from_sum,
+        jt_isim_unpacked,
+        jt_isim_packed,
+        _jt_sim_arr_vec_packed,
+        jt_most_dissimilar_packed,
+    )
+else:
+    try:
+        from bblean._cpp_similarity import (  # type: ignore
+            jt_isim_from_sum,
+            _jt_sim_arr_vec_packed,
+            jt_isim_unpacked_u8,
+            jt_isim_packed_u8,
+            jt_most_dissimilar_packed,
+            unpack_fingerprints,
+        )
+
+        # Wrap these two since doing
+        def jt_isim_unpacked(arr: NDArray[np.integer]) -> float:
+            # Wrapping like this is slightly faster than letting pybind11 autocast
+            if arr.dtype == np.uint64:
+                return jt_isim_from_sum(
+                    np.sum(arr, axis=0, dtype=np.uint64), len(arr)  # type: ignore
+                )
+            return jt_isim_unpacked_u8(arr)
+
+        # Probably a mypy bug
+        def jt_isim_packed(  # type: ignore
+            arr: NDArray[np.integer], n_features: int | None = None
+        ) -> float:
+            # Wrapping like this is slightly faster than letting pybind11 autocast
+            if arr.dtype == np.uint64:
+                return jt_isim_from_sum(
+                    np.sum(
+                        unpack_fingerprints(arr, n_features),  # type: ignore
+                        axis=0,
+                        dtype=np.uint64,
+                    ),
+                    len(arr),
+                )
+            return jt_isim_packed_u8(arr)
+
+    except ImportError:
+        from bblean._py_similarity import (  # type: ignore
+            jt_isim_from_sum,
+            jt_isim_unpacked,
+            jt_isim_packed,
+            _jt_sim_arr_vec_packed,
+            jt_most_dissimilar_packed,
+        )
+
+        warnings.warn(
+            "C++ optimized similarity calculations not available,"
+            " falling back to python implementation"
+        )
+
+
+def jt_isim(
+    fps: NDArray[np.integer],
+    input_is_packed: bool = True,
+    n_features: int | None = None,
+) -> float:
+    r"""Average Tanimoto, using iSIM
+
+    iSIM Tanimoto was first propsed in:
+    https://pubs.rsc.org/en/content/articlelanding/2024/dd/d4dd00041b
+
+    :math:`iSIM_{JT}(X)` is an excellent :math:`O(N)` approximation of the average
+    Tanimoto similarity of a set of fingerprints.
+
+    Also equivalent to the complement of the Tanimoto diameter
+    :math:`iSIM_{JT}(X) = 1 - D_{JT}(X)`.
+
+    Parameters
+    ----------
+    arr : np.ndarray
+        2D fingerprint array
+
+    input_is_packed : bool
+        Whether the input array has packed fingerprints
+
+    n_features: int | None
+        Number of features when unpacking fingerprints. Only required if
+        not a multiple of 8
+
+    Returns
+    ----------
+    isim : float
+           iSIM Jaccard-Tanimoto value
+    """
+    if input_is_packed:
+        return jt_isim_packed(fps, n_features)
+    return jt_isim_unpacked(fps)
+
+
+def jt_isim_diameter(
+    arr: NDArray[np.integer],
+    input_is_packed: bool = True,
+    n_features: int | None = None,
+) -> float:
+    r"""Calculate the Tanimoto diameter of a set of fingerprints"""
+    return jt_isim_diameter_from_sum(
+        np.sum(
+            unpack_fingerprints(arr, n_features) if input_is_packed else arr,
+            axis=0,
+            dtype=np.uint64,
+        ),  # type: ignore
+        len(arr),
+    )
+
+
+def jt_isim_radius(
+    arr: NDArray[np.integer],
+    input_is_packed: bool = True,
+    n_features: int | None = None,
+) -> float:
+    r"""Calculate the Tanimoto radius of a set of fingerprints"""
+    return jt_isim_radius_from_sum(
+        np.sum(
+            unpack_fingerprints(arr, n_features) if input_is_packed else arr,
+            axis=0,
+            dtype=np.uint64,
+        ),  # type: ignore
+        len(arr),
+    )
+
+
+def jt_isim_radius_compl(
+    arr: NDArray[np.integer],
+    input_is_packed: bool = True,
+    n_features: int | None = None,
+) -> float:
+    r"""Calculate the complement of the Tanimoto radius of a set of fingerprints"""
+    return jt_isim_radius_compl_from_sum(
+        np.sum(
+            unpack_fingerprints(arr, n_features) if input_is_packed else arr,
+            axis=0,
+            dtype=np.uint64,
+        ),  # type: ignore
+        len(arr),
+    )
+
+
+def jt_isim_radius_compl_from_sum(ls: NDArray[np.integer], n: int) -> float:
+    r"""Calculate the complement of the Tanimoto radius of a set of fingerprints"""
+    #  Calculates 1 - R = Rc
+    # NOTE: Use uint64 sum since jt_isim_from_sum casts to uint64 internally
+    # This prevents multiple casts
+    new_unpacked_centroid = centroid_from_sum(ls, n, pack=False)
+    new_ls_1 = np.add(ls, new_unpacked_centroid, dtype=np.uint64)
+    new_n_1 = n + 1
+    new_jt = jt_isim_from_sum(ls, n)
+    new_jt_1 = jt_isim_from_sum(new_ls_1, new_n_1)
+    return (new_jt_1 * new_n_1 - new_jt * (n - 1)) / 2
+
+
+def jt_isim_radius_from_sum(ls: NDArray[np.integer], n: int) -> float:
+    r"""Calculate the Tanimoto radius of a set of fingerprints"""
+    return 1 - jt_isim_radius_compl_from_sum(ls, n)
+
+
+def jt_isim_diameter_from_sum(ls: NDArray[np.integer], n: int) -> float:
+    r"""Calculate the Tanimoto diameter of a set of fingerprints.
+
+    Equivalent to ``1 - jt_isim_from_sum(ls, n)``"""
+    return 1 - jt_isim_from_sum(ls, n)
+
+
+# General wrapper that works both in C++ and python
+def jt_sim_packed(
+    x: NDArray[np.uint8],
+    y: NDArray[np.uint8],
+) -> NDArray[np.float64]:
+    r"""Tanimoto similarity between packed fingerprints
+
+    Either both inputs are vectors of shape (F,) (Numpy scalar is returned), or
+    one is an vector (F,) and the other an array of shape (N, F) (Numpy array of
+    shape (N,) is returned).
+    """
+    if x.ndim == 1 and y.ndim == 1:
+        return _jt_sim_arr_vec_packed(x.reshape(1, -1), y)[0]
+    if x.ndim == 2:
+        return _jt_sim_arr_vec_packed(x, y)
+    if y.ndim == 2:
+        return _jt_sim_arr_vec_packed(y, x)
+    raise ValueError(
+        "Expected either two 1D vectors, or one 1D vector and one 2D array"
+    )
+
+
+def jt_sim_matrix_packed(arr: NDArray[np.uint8]) -> NDArray[np.float64]:
+    r"""Tanimoto similarity matrix between all pairs of packed fps in arr"""
+    matrix = np.ones((len(arr), len(arr)), dtype=np.float64)
+    for i in range(len(arr)):
+        # Set the similarities for each row
+        matrix[i, i + 1 :] = jt_sim_packed(arr[i], arr[i + 1 :])
+        # Set the similarities for each column (symmetric)
+        matrix[i + 1 :, i] = matrix[i, i + 1 :]
+    return matrix
+
+
+def estimate_jt_std(
+    fps: NDArray[np.uint8],
+    n_samples: int | None = None,
+    input_is_packed: bool = True,
+    n_features: int | None = None,
+) -> float:
+    r"""Estimate std of tanimoto sim using a deterministic sample"""
+    num_fps = len(fps)
+    if n_samples is None:
+        n_samples = max(num_fps // 1000, 50)
+    sample_idxs = jt_stratified_sampling(fps, n_samples, input_is_packed, n_features)
+
+    # Work with sample from now on
+    fps = fps[sample_idxs]
+    num_fps = len(fps)
+    pairs = np.empty(num_fps * (num_fps - 1) // 2, dtype=np.float64)
+    # NOTE: Calc upper triangular part of pairwise matrix only, slightly more efficient,
+    # but difference is negligible in tests
+    offset = 0
+    for i in range(len(fps)):
+        num = num_fps - i - 1
+        pairs[offset : offset + num] = jt_sim_packed(fps[i], fps[i + 1 :])
+        offset += num
+    return np.std(pairs).item()
+
+
+def jt_stratified_sampling(
+    fps: NDArray[np.uint8],
+    n_samples: int,
+    input_is_packed: bool = True,
+    n_features: int | None = None,
+) -> NDArray[np.int64]:
+    r"""Sample from a set of fingerprints according to their complementary similarity
+
+    Given a group of fingerprints, calculate all complementary similarities, order, and
+    sample the first element from consecutive groups of length ``num_fps // n_samples +
+    1``.
+
+    ..  note ::
+
+        This is not true statistical stratified sampling, it is not random, and the
+        strata are not homogeneous. It is meant as a reliable, deterministic method to
+        obtain a representative sample from a set of fingerprints.
+    """
+    # Stratified sampling without replacement
+    if n_samples == 0:
+        return np.array([], dtype=np.int64)
+    if n_samples > len(fps):
+        raise ValueError("n_samples must be <= len(fps)")
+    # Get the indices that would sort the complementary similarities
+    sorted_indices = np.argsort(jt_compl_isim(fps, input_is_packed, n_features))
+    # Split into n_samples strata
+    strata = np.array_split(sorted_indices, n_samples)
+    # Get first index of each strata
+    return np.array([s[0] for s in strata])

bblean/sklearn.py

@@ -0,0 +1,203 @@
+r"""BitBirch 'Lean' classes that fully respects the sklearn API contract.
+
+Use these classes as a drop-in replacement of `sklearn.cluster.Birch` if you are used to
+the `sklearn` way of doing things, with the caveat that global clustering is not
+currently supported.
+"""
+
+import typing as tp
+from numpy.typing import NDArray
+import numpy as np
+import typing_extensions as tpx
+
+from sklearn.utils.validation import check_is_fitted, validate_data
+from sklearn.metrics import pairwise_distances_argmin, pairwise_distances
+from sklearn.base import (
+    BaseEstimator,
+    ClassNamePrefixFeaturesOutMixin,
+    ClusterMixin,
+    TransformerMixin,
+    _fit_context,
+)
+
+from bblean.fingerprints import unpack_fingerprints
+from bblean.bitbirch import BitBirch as _BitBirch
+from bblean._merges import MergeAcceptFunction
+
+__all__ = ["BitBirch", "UnpackedBitBirch"]
+
+# Required functions for sklearn API:
+# - fit() *must be defined*
+# - transform()  *must be defined*
+# - fit_predict()  (ClusterMixin) default implementation is to fit and then return lbls
+# - predict()  # overloaded to use jt instead of euclidean
+# - fit_transform()  (TransformerMixin, delegates to *fit* and *transform*)
+# - set_output()  (TransformerMixin via _SetOutputMixin)
+# set_output(transform="pandas") or transform="default" (numpy array) (or "polars",
+# if polars is installed)
+
+#  The following requires _n_features_out after fitting
+# - get_feature_names_out() ["bitbirch0", "bitbirch1", ...] (ClassNamePrefix...)
+
+# - get_metadata_routing() () (!?) New feature, unclear what this is and unnecessary
+# - partial_fit() ()  Same as fit() for BitBirch
+
+# These require that the parameters are specified in __init__, and are assigned
+# to names (or attributes) with the convention self.<param>.
+# - get_params() (BaseEstimator)
+# - set_params() (BaseEstimator)
+
+
+class BitBirch(
+    ClassNamePrefixFeaturesOutMixin,
+    ClusterMixin,
+    TransformerMixin,
+    BaseEstimator,
+    _BitBirch,
+):
+    r"""Implements the BitBIRCH clustering algorithm, 'Lean' version.
+
+    Inputs to this estimator are *packed* fingerprints by default. If you need get a
+    class that always accepts an unpacked input use `bblean.sklearn.UnpackedBitBirch`
+
+    See `bblean.bitbirch.BitBirch` for more details"""
+
+    _parameter_constraints: dict[str, list[tp.Any]] = {}
+
+    def __init__(
+        self,
+        *,
+        threshold: float = 0.65,
+        branching_factor: int = 50,
+        merge_criterion: str | MergeAcceptFunction | None = None,
+        tolerance: float | None = None,
+        compute_labels: bool = True,
+    ):
+        super().__init__(
+            threshold=threshold,
+            branching_factor=branching_factor,
+            merge_criterion=merge_criterion,
+            tolerance=tolerance,
+        )
+        self.compute_labels = compute_labels
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def fit(  # type: ignore
+        self, X, y=None, input_is_packed: bool = True, n_features: int | None = None
+    ) -> tpx.Self:
+        super().fit(X, input_is_packed=input_is_packed, n_features=n_features)
+        centroids = np.stack(
+            [bf.unpacked_centroid for bf in self._get_leaf_bfs(sort=True)]
+        )
+        self.subcluster_centers_ = centroids
+        self.subcluster_labels_ = np.arange(1, len(centroids) + 1)
+        self._n_features_out = centroids.shape[0]
+        if self.compute_labels:
+            self.labels_ = self.get_assignments()
+        return self
+
+    @_fit_context(prefer_skip_nested_validation=True)
+    def partial_fit(  # type: ignore
+        self,
+        X=None,
+        y=None,
+        input_is_packed: bool = True,
+        n_features: int | None = None,
+    ) -> tpx.Self:
+        if X is None:
+            raise ValueError()
+        self.fit(X, input_is_packed=input_is_packed, n_features=n_features)
+        if self.compute_labels:
+            self.labels_ = self.get_assignments()
+        return self
+
+    # Overloaded since self.labels_ may not be set
+    def fit_predict(  # type: ignore
+        self, X, y=None, input_is_packed: bool = True, n_features: int | None = None
+    ) -> NDArray[np.integer]:
+        self.fit(X, input_is_packed=input_is_packed, n_features=n_features)
+        if not self.compute_labels:
+            self.labels_ = self.get_assignments()
+        return self.labels_
+
+    def predict(  # type: ignore
+        self, X, input_is_packed: bool = True, n_features: int | None = None
+    ) -> NDArray[np.integer]:
+        """Predict data using the ``centroids`` of subclusters."""
+        check_is_fitted(self)
+        X = validate_data(self, X, accept_sparse="csr", reset=False)
+        X = (
+            (unpack_fingerprints(X, n_features=n_features) if input_is_packed else X)
+            .astype(np.uint8, copy=False)
+            .view(np.bool)
+        )
+        # TODO: Even when both inputs are bool, this function warns for some reason
+        # I believe this may be a sklearn bug
+        centers = self.subcluster_centers_.astype(np.uint8, copy=False).view(np.bool)
+        argmin = pairwise_distances_argmin(X, centers, metric="jaccard")
+        return self.subcluster_labels_[argmin]
+
+    def transform(  # type: ignore
+        self,
+        X,
+        input_is_packed: bool = True,
+        n_features: int | None = None,
+    ):
+        check_is_fitted(self)
+        X = validate_data(self, X, accept_sparse="csr", reset=False)
+        X = (
+            (unpack_fingerprints(X, n_features=n_features) if input_is_packed else X)
+            .astype(np.uint8, copy=False)
+            .view(np.bool)
+        )
+        centers = self.subcluster_centers_.astype(np.uint8, copy=False).view(np.bool)
+        return pairwise_distances(X, centers, metric="jaccard")
+
+    def __sklearn_tags__(self):  # type: ignore
+        tags = super().__sklearn_tags__()
+        tags.input_tags.sparse = True
+        return tags
+
+
+class UnpackedBitBirch(BitBirch):
+    r"""Implements the BitBIRCH clustering algorithm, 'Lean' version.
+
+    Inputs to this estimator are *unpacked* fingerprints always
+
+    See `bblean.bitbirch.BitBirch` for more details"""
+
+    def fit(  # type: ignore
+        self, X, y=None, input_is_packed: bool = False, n_features: int | None = None
+    ) -> tpx.Self:
+        return super().fit(X, y, input_is_packed=input_is_packed, n_features=n_features)
+
+    def partial_fit(  # type: ignore
+        self, X, y=None, input_is_packed: bool = False, n_features: int | None = None
+    ):
+        return super().partial_fit(
+            X, y, input_is_packed=input_is_packed, n_features=n_features
+        )
+
+    def fit_predict(  # type: ignore
+        self, X, y=None, input_is_packed: bool = False, n_features: int | None = None
+    ):
+        return super().fit_predict(
+            X, y, input_is_packed=input_is_packed, n_features=n_features
+        )
+
+    def predict(  # type: ignore
+        self,
+        X,
+        input_is_packed: bool = False,
+        n_features: int | None = None,
+    ):
+        return super().predict(
+            X, input_is_packed=input_is_packed, n_features=n_features
+        )
+
+    def transform(  # type: ignore
+        self, X, input_is_packed: bool = False, n_features: int | None = None
+    ):
+        return super().transform(
+            X, input_is_packed=input_is_packed, n_features=n_features
+        )

bblean/smiles.py

@@ -0,0 +1,61 @@
+r"""SMILES manipulation"""
+
+import typing as tp
+from numpy.typing import NDArray
+import numpy as np
+from pathlib import Path
+
+from bblean.utils import batched
+
+__all__ = [
+    "load_smiles",
+    "calc_num_smiles",
+    "iter_smiles_from_paths",
+]
+
+SmilesPaths = tp.Iterable[Path | str] | Path | str
+
+
+def load_smiles(smiles_paths: SmilesPaths, max_num: int = -1) -> NDArray[np.str_]:
+    r"""Simple utility to load smiles from a ``*.smi`` file"""
+    smiles = []
+    for i, smi in enumerate(iter_smiles_from_paths(smiles_paths)):
+        if i == max_num:
+            break
+        smiles.append(smi)
+    return np.asarray(smiles)
+
+
+def calc_num_smiles(smiles_paths: SmilesPaths) -> int:
+    r"""Get the total number of smiles in a sequene of paths"""
+    return sum(1 for _ in iter_smiles_from_paths(smiles_paths))
+
+
+def iter_smiles_from_paths(
+    smiles_paths: SmilesPaths,
+) -> tp.Iterator[str]:
+    r"""Iterate over smiles in a sequence of smiles paths"""
+    if isinstance(smiles_paths, (Path, str)):
+        smiles_paths = [smiles_paths]
+    for smi_path in smiles_paths:
+        with open(smi_path, mode="rt", encoding="utf-8") as f:
+            for smi in f:
+                yield smi
+
+
+def _iter_ranges_and_smiles_batches(
+    smiles_paths: SmilesPaths,
+    num_per_batch: int,
+) -> tp.Iterable[tuple[tuple[int, int], tuple[str, ...]]]:
+    start_idx = 0
+    for batch in batched(iter_smiles_from_paths(smiles_paths), num_per_batch):
+        size = len(batch)
+        end_idx = start_idx + size
+        yield (start_idx, end_idx), batch
+        start_idx = end_idx
+
+
+def _iter_idxs_and_smiles_batches(
+    smiles_paths: SmilesPaths, num_per_batch: int
+) -> tp.Iterable[tuple[int, tuple[str, ...]]]:
+    yield from enumerate(batched(iter_smiles_from_paths(smiles_paths), num_per_batch))

bblean/utils.py

@@ -0,0 +1,130 @@
+r"""Misc. utility functions"""
+
+import os
+from pathlib import Path
+import itertools
+import typing as tp
+import sys
+import subprocess
+import platform
+import importlib
+
+import psutil
+import numpy as np
+
+__all__ = [
+    "batched",
+    "min_safe_uint",
+    "cpp_extensions_are_enabled",
+    "cpp_extensions_are_installed",
+]
+
+_T = tp.TypeVar("_T")
+
+
+def min_safe_uint(nmax: int) -> np.dtype:
+    r"""Returns the min uint dtype that holds a (positive) py int, excluding "object".
+
+    Input must be a positive python integer.
+    """
+    out = np.min_scalar_type(nmax)
+    # Check if the dtype is a pointer to a python bigint
+    if out.hasobject:
+        raise ValueError(f"n_samples: {nmax} is too large to hold in a uint64 array")
+    return out
+
+
+# Itertools recipe
+def batched(iterable: tp.Iterable[_T], n: int) -> tp.Iterator[tuple[_T, ...]]:
+    r"""Batch data into tuples of length n. The last batch may be shorter.
+
+    This is equivalent to the batched receip from `itertools`.
+    """
+    # batched('ABCDEFG', 3) --> ('A', 'B', 'C') ('D', 'E', 'F') ('G',)
+    if n < 1:
+        raise ValueError("n must be at least one")
+    it = iter(iterable)
+    while batch := tuple(itertools.islice(it, n)):
+        yield batch
+
+
+def _import_bitbirch_variant(
+    variant: str = "lean",
+) -> tuple[tp.Any, tp.Callable[..., None]]:
+    if variant not in ("lean", "int64", "uint8"):
+        raise ValueError(f"Unknown variant {variant}")
+    if variant == "lean":
+        # Most up-to-date bb variant
+        module = importlib.import_module("bblean.bitbirch")
+    elif variant == "uint8":
+        # Legacy variant of bb that uses uint8 and supports packing, but no extra optim
+        module = importlib.import_module("bblean._legacy.bb_uint8")
+    elif variant == "int64":
+        # Legacy variant of bb that uses int64 fps (dense only)
+        module = importlib.import_module("bblean._legacy.bb_int64")
+
+    Cls = getattr(module, "BitBirch")
+    fn = getattr(module, "set_merge")
+    return Cls, fn
+
+
+def _num_avail_cpus() -> int:
+    if sys.platform == "darwin":
+        # macOS doesn't expose cpu affinity, so assume all cpu's are available
+        return os.cpu_count()
+    return len(psutil.Process().cpu_affinity())
+
+
+def _cpu_name() -> str:
+    if sys.platform == "darwin":
+        try:
+            return subprocess.run(
+                ["sysctl", "-n", "machdep.cpu.brand_string"],
+                capture_output=True,
+                text=True,
+                check=True,
+            ).stdout.strip()
+        except Exception:
+            pass
+
+    if sys.platform == "linux":
+        with open("/proc/cpuinfo") as f:
+            for line in f:
+                if line.startswith("model name"):
+                    return line.split(":", 1)[1].strip()
+
+    # Fallback for windows and all cases where it could not be found
+    return platform.processor()
+
+
+def _has_files_or_valid_symlinks(path: Path) -> bool:
+    has_files = False
+    for p in path.iterdir():
+        if p.is_symlink() and not p.exists():
+            return False
+
+        if p.is_file():
+            has_files = True
+    return has_files
+
+
+def cpp_extensions_are_enabled() -> bool:
+    r"""Query whether the C++ BitBRICH extensions are currently enabled"""
+    if os.getenv("BITBIRCH_NO_EXTENSIONS"):
+        return False
+    try:
+        from bblean._cpp_similarity import jt_isim_from_sum  # noqa
+
+        return True
+    except ImportError:
+        return False
+
+
+def cpp_extensions_are_installed() -> bool:
+    r"""Query whether the C++ BitBRICH extensions are currently installed"""
+    try:
+        from bblean._cpp_similarity import jt_isim_from_sum  # noqa
+
+        return True
+    except ImportError:
+        return False