spatiomic 0.4.0__py3-none-any.whl

spatiomic/__init__.py

@@ -0,0 +1,22 @@
+"""Library for spatial omics analysis. Lazy-loads submodules for faster import times."""
+
+from importlib.util import find_spec
+from typing import List
+
+import lazy_loader as lazy
+
+from ._version import __version__ as __version__
+
+__getattr__, __lazy_dir__, _ = lazy.attach_stub(__name__, __file__)
+
+
+def __dir__() -> List[str]:
+    """List the available submodules."""
+    return [*__lazy_dir__(), "__version__"]
+
+
+if find_spec("cuml") is not None:
+    import cuml  # type: ignore
+
+    # Always return the cuml results as np.ndarray, this ensures compatibility between GPU and CPU algorithms
+    cuml.set_global_output_type("numpy")

spatiomic/__init__.pyi

@@ -0,0 +1,18 @@
+"""Spatiomic: Spatial omics analyses in Python."""
+
+from ._version import __version__
+
+submodules = [
+    "cluster",
+    "data",
+    "dimension",
+    "neighbor",
+    "plot",
+    "process",
+    "spatial",
+    "tool",
+]
+
+__all__ = submodules + ["__version__"]
+
+from . import cluster, data, dimension, neighbor, plot, process, spatial, tool  # noqa: F401

spatiomic/_internal/__init__.py

@@ -0,0 +1,9 @@
+"""Internal utility functions.
+
+The functions in this module are not intended to be used directly by the user and are thus not accesible without
+the explicit underscore file name imports from the top-level package.
+"""
+
+from typing import List
+
+__all__: List[str] = []

spatiomic/_internal/_anndata_method.py

@@ -0,0 +1,268 @@
+import inspect
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Tuple
+
+import numpy as np
+import pandas as pd
+from anndata import AnnData
+from numpy.typing import ArrayLike, NDArray
+
+from ._import_package import import_package
+
+
+def _get_data_from_anndata(
+    adata: AnnData,
+    input_attribute_name: Optional[str] = None,
+    input_layer_name: Optional[str] = None,
+    input_obs_name: Optional[str] = None,
+    input_obsm_name: Optional[str] = None,
+    input_var_name: Optional[str] = None,
+    input_varm_name: Optional[str] = None,
+    input_uns_name: Optional[str] = None,
+) -> NDArray:
+    """Extract NDArray data from AnnData object based on input parameters."""
+    if input_attribute_name is not None:
+        return_value = getattr(adata, input_attribute_name)
+    elif input_layer_name is not None:
+        return_value = adata.layers[input_layer_name]
+    elif input_obs_name is not None:
+        obs_data = adata.obs[input_obs_name]
+        return_value = obs_data.to_numpy() if isinstance(obs_data, (pd.DataFrame, pd.Series)) else obs_data
+    elif input_obsm_name is not None:
+        return_value = adata.obsm[input_obsm_name]
+    elif input_var_name is not None:
+        var_data = adata.var[input_var_name]
+        return_value = var_data.to_numpy() if isinstance(var_data, (pd.DataFrame, pd.Series)) else var_data
+    elif input_varm_name is not None:
+        return_value = adata.varm[input_varm_name]
+    elif input_uns_name is not None:
+        return_value = adata.uns[input_uns_name]
+    else:
+        return_value = adata.X.toarray()
+
+    if not isinstance(return_value, ArrayLike) and not isinstance(return_value, np.ndarray):
+        raise TypeError("Returned data must be a numpy array.")
+    elif isinstance(return_value, ArrayLike):
+        return_value = np.array(return_value)
+
+    return return_value
+
+
+def _store_data_in_anndata(
+    adata: AnnData,
+    result: NDArray,
+    output_layer_name: Optional[str] = None,
+    output_obsm_name: Optional[str] = None,
+    output_obs_name: Optional[str] = None,
+    output_varm_name: Optional[str] = None,
+    output_var_name: Optional[str] = None,
+    output_uns_name: Optional[str] = None,
+) -> None:
+    """Store result NDArray data into AnnData object based on output parameters."""
+    if output_layer_name is not None:
+        adata.layers[output_layer_name] = result
+    elif output_obsm_name is not None:
+        adata.obsm[output_obsm_name] = result
+    elif output_obs_name is not None:
+        adata.obs[output_obs_name] = result
+    elif output_varm_name is not None:
+        adata.varm[output_varm_name] = result
+    elif output_var_name is not None:
+        adata.var[output_var_name] = result
+    elif output_uns_name is not None:
+        adata.uns[output_uns_name] = result
+
+
+def anndata_method(
+    pass_data: bool = True,
+    input_attribute: Optional[str] = None,
+    input_layer: Optional[str] = None,
+    input_obs: Optional[str] = None,
+    input_obsm: Optional[str] = None,
+    input_var: Optional[str] = None,
+    input_varm: Optional[str] = None,
+    input_uns: Optional[str] = None,
+    output_layer: Optional[str] = None,
+    output_obsm: Optional[str] = None,
+    output_obs: Optional[str] = None,
+    output_varm: Optional[str] = None,
+    output_var: Optional[str] = None,
+    output_uns: Optional[str] = None,
+    result_index: Optional[int] = None,
+) -> Callable:
+    """Decorator to handle AnnData input and output for methods.
+
+    This decorator simplifies the process of writing methods that can work with both AnnData objects
+    and raw NDArrays/DataFrames. It automatically extracts data from AnnData based on specified
+    input parameters and stores the result back into AnnData based on output parameters.
+
+    .. code-block:: python
+        @anndata_method(pass_data=True, input_obs="obs_column", output_uns="my_method_result")
+        def my_method(data: NDArray) -> NDArray:
+            return data
+
+
+        adata = AnnData(X=np.random.rand(10, 10))
+        adata.obs["obs_column"] = np.random.rand(10)
+
+        # The result will be stored in adata.uns["my_method_result"] but the method will still return the result
+        result = my_method(adata)
+
+    .. note::
+        User provided input/output parameter names will override the default parameter names. If the user provides
+        multiple input/output parameter names, the order of precedence is as follows:
+        input_attribute > input_layer > input_obs > input_obsm > input_var > input_varm > input_uns
+        output_layer > output_obs > output_obsm > output_var > output_varm > output_uns
+
+    .. note::
+        If the decorated method returns a tuple, the index of the element to store in AnnData can be specified
+        with the `result_index` parameter.
+
+    Args:
+        pass_data (bool, optional): Whether to pass the extracted data to the decorated method. Defaults to True.
+        input_attribute (Optional[str]): Attribute name in AnnData to retrieve data from (e.g., 'raw').
+        input_layer (Optional[str]): Layer name in AnnData to retrieve data from.
+        input_obs (Optional[str]): .obs column name in AnnData to retrieve data from.
+        input_obsm (Optional[str]): .obsm name in AnnData to retrieve data from.
+        input_var (Optional[str]): .var column name in AnnData to retrieve data from.
+        input_varm (Optional[str]): .varm name in AnnData to retrieve data from.
+        input_uns (Optional[str]): .uns key in AnnData to retrieve data from.
+        output_layer (Optional[str]): Layer name in AnnData to store the result.
+        output_obsm (Optional[str]): .obsm name in AnnData to store the result.
+        output_obs (Optional[str]): .obs column name in AnnData to store the result.
+        output_varm (Optional[str]): .varm name in AnnData to store the result.
+        output_var (Optional[str]): .var column name in AnnData to store the result.
+        output_uns (Optional[str]): .uns key in AnnData to store the result.
+        result_index (Optional[int]): If the decorated method returns a tuple, this index specifies which element of the
+            tuple to store in AnnData. Defaults to None (store the first element).
+
+    Returns:
+        Callable: The decorated method.
+
+    Raises:
+        ValueError: If 'data' argument is missing when pass_data=True and no AnnData object found in arguments.
+        TypeError: If 'data' is not AnnData, DataFrame, or NDArray when pass_data=True.
+    """
+
+    def decorator(method: Callable) -> Callable:
+        @wraps(method)
+        def wrapper(
+            *args: Tuple[Any, ...],
+            **kwargs: Dict[str, Any],
+        ) -> Any:
+            method_signature = inspect.signature(method)
+            parameters = method_signature.parameters
+            has_self = "self" in parameters
+
+            self_obj = None
+            processed_args: list[Any] = list(args)  # Convert to list for easier manipulation
+
+            if has_self:
+                self_index = list(parameters.keys()).index("self")
+                if len(processed_args) > self_index:
+                    self_obj = processed_args.pop(self_index)
+
+            if TYPE_CHECKING:
+                xp = np
+            else:
+                xp: "np" = import_package("cupy", alternative=np)
+
+            data_arg = kwargs.pop("data", None)
+            if (
+                data_arg is None
+                and processed_args
+                and isinstance(processed_args[0], (AnnData, pd.DataFrame, np.ndarray, xp.ndarray))
+            ):
+                data_arg = processed_args.pop(0)
+
+            array_data = None
+            adata_obj = None
+
+            if isinstance(data_arg, AnnData):
+                adata_obj = data_arg
+
+                input_params: Dict[str, Optional[str]] = {
+                    "input_attribute_name": kwargs.pop("input_attribute", input_attribute),  # type: ignore
+                    "input_layer_name": kwargs.pop("input_layer", input_layer),  # type: ignore
+                    "input_obs_name": kwargs.pop("input_obs", input_obs),  # type: ignore
+                    "input_obsm_name": kwargs.pop("input_obsm", input_obsm),  # type: ignore
+                    "input_var_name": kwargs.pop("input_var", input_var),  # type: ignore
+                    "input_varm_name": kwargs.pop("input_varm", input_varm),  # type: ignore
+                    "input_uns_name": kwargs.pop("input_uns", input_uns),  # type: ignore
+                }
+                array_data = _get_data_from_anndata(adata_obj, **input_params)
+
+                output_params: Dict[str, Optional[str]] = {
+                    "output_layer_name": kwargs.pop("output_layer", output_layer),  # type: ignore
+                    "output_obs_name": kwargs.pop("output_obs", output_obs),  # type: ignore
+                    "output_obsm_name": kwargs.pop("output_obsm", output_obsm),  # type: ignore
+                    "output_var_name": kwargs.pop("output_var", output_var),  # type: ignore
+                    "output_varm_name": kwargs.pop("output_varm", output_varm),  # type: ignore
+                    "output_uns_name": kwargs.pop("output_uns", output_uns),  # type: ignore
+                }
+                result_index_parsed = kwargs.pop("result_index", result_index)
+
+            elif data_arg is not None and isinstance(data_arg, (pd.DataFrame, np.ndarray, xp.ndarray)):
+                array_data = data_arg
+            elif pass_data:
+                raise ValueError("Data argument missing.")
+            elif data_arg is not None:  # this case should not raise TypeError if pass_data=False
+                raise TypeError("Data must be an AnnData object, DataFrame or NDArray if pass_data=True.")
+
+            method_args = [self_obj] if self_obj else []
+            if pass_data and array_data is not None:  # Only pass data if pass_data is True and we have data to pass
+                method_args.append(array_data)
+
+            result = method(*method_args, *processed_args, **kwargs)
+
+            if adata_obj is not None:
+                ad_result_to_store = result
+                if isinstance(result, tuple):
+                    result_index_parsed = 0 if result_index_parsed is None else result_index_parsed
+                    if isinstance(result_index_parsed, int) and 0 <= result_index_parsed < len(result):
+                        ad_result_to_store = result[result_index_parsed]
+                    else:
+                        ad_result_to_store = result[0]  # default to first element if index invalid
+
+                if xp.__name__ == "cupy" and isinstance(ad_result_to_store, xp.ndarray):
+                    ad_result_to_store = ad_result_to_store.get()  # type: ignore
+
+                if isinstance(ad_result_to_store, np.ndarray):  # only store numpy array-like results in AnnData
+                    _store_data_in_anndata(
+                        adata_obj,
+                        ad_result_to_store,
+                        **output_params,
+                    )
+
+            return result
+
+        wrapper.__doc__ = method.__doc__
+
+        additional_doc = """
+
+        This method can be used with both AnnData objects and raw NDArrays/DataFrames. If an AnnData object is provided,
+        the data will be extracted based on the following parameters:
+            - input_attribute: Name of the attribute in AnnData to extract data from.
+            - input_layer: Name of the layer in AnnData to extract data from.
+            - input_obs: Column in AnnData.obs to extract data from.
+            - input_obsm: Key in AnnData.obsm to extract data from.
+            - input_var: Column in AnnData.var to extract data from.
+            - input_varm: Key in AnnData.varm to extract data from.
+            - input_uns: Key in AnnData.uns to extract data from.
+
+        The result will be stored back into the AnnData object based on the following parameters:
+            - output_layer: Name of the layer in AnnData to store the result.
+            - output_obs: Column in AnnData.obs to store the result.
+            - output_obsm: Key in AnnData.obsm to store the result.
+            - output_var: Column in AnnData.var to store the result.
+            - output_varm: Key in AnnData.varm to store the result.
+            - output_uns: Key in AnnData.uns to store the result.
+        """
+        if wrapper.__doc__:
+            wrapper.__doc__ += additional_doc
+        else:
+            wrapper.__doc__ = additional_doc
+
+        return wrapper
+
+    return decorator

spatiomic/_internal/_check_channel_dimension.py

@@ -0,0 +1,43 @@
+from typing import Optional
+from warnings import warn
+
+
+def check_channel_dimension(
+    data_shape: tuple,
+    dimension_count_min: Optional[int] = 2,
+    dimension_count_max: Optional[int] = None,
+) -> None:
+    """Check if the data has a channel dimension and warn if not or raise an error if the data is 2D and square.
+
+    Args:
+        data_shape (tuple): The shape of the data.
+        dimension_count_min (Optional[int], optional): The minimum number of dimensions the data must have.
+            Defaults to 2.
+        dimension_count_max (Optional[int], optional): The maximum number of dimensions the data must have.
+            Defaults to None.
+
+    Raises:
+        ValueError: If the data is 2D and square.
+
+    Warns:
+        UserWarning: If the data is 2D and has no channel dimension but is not square.
+    """
+    if dimension_count_min is not None:
+        assert len(data_shape) >= dimension_count_min, f"Data must have at least {dimension_count_min} dimensions."
+    if dimension_count_max is not None:
+        assert len(data_shape) <= dimension_count_max, f"Data must have at most {dimension_count_max} dimensions."
+
+    if len(data_shape) == 2:
+        # check if the image is close to a square
+        if abs(data_shape[0] - data_shape[1]) < max(data_shape) * 0.2:
+            raise ValueError(
+                "Data has only two dimensions and is square, assuming image without channel dimension."
+                "Please add a channel dimension to the data for correct processing."
+            )
+        else:
+            warn(
+                "Data has only two dimensions. Assuming flat data with one channel dimension."
+                " This will yield unwanted results when called on 2D images without channel dimension.",
+                UserWarning,
+                stacklevel=2,
+            )

spatiomic/_internal/_data_method.py

@@ -0,0 +1,85 @@
+import inspect
+import warnings
+from functools import wraps
+from typing import TYPE_CHECKING, Any, Callable
+
+import numpy as np
+import pandas as pd
+
+from spatiomic._internal._import_package import import_package
+
+
+def data_method(method: Callable) -> Callable:
+    """Automatically check and get the values from the data parameter for the decorated function.
+
+    Args:
+        method (Callable): The decorated method that takes the processed data.
+
+    Returns:
+        Callable: A wrapper function that invokes the passed method with the processed data.
+    """
+
+    @wraps(method)
+    def wrapper(
+        *args: Any,
+        **kwargs: dict,
+    ) -> Any:
+        """Get float NDArray data from passed data and invoke the decorated method with the processed data.
+
+        Args:
+            self (object): The reference to the object containing the decorated method.
+            data (Union[NDArray, pd.DataFrame, MultiplexedImage, MultiplexedImageCollection]): The data source.
+
+        Returns:
+            Any: The result of the invoked method.
+        """
+        # Check if 'self' is present as an argument
+        method_signature = inspect.signature(method)
+        parameters = method_signature.parameters
+
+        has_self = "self" in parameters
+
+        if has_self:
+            self_index = list(parameters.keys()).index("self")
+            self = args[self_index]
+            args = args[:self_index] + args[self_index + 1 :]
+        else:
+            self = None
+
+        # Check if 'data' is present as a keyword argument, otherwise check if it is the first argument
+        data = kwargs.pop("data", None)
+        if data is None and len(args) > 0:
+            data = args[0]
+            args = args[1:]
+
+        if TYPE_CHECKING:
+            xp = np
+        else:
+            xp: "np" = import_package("cupy", alternative=np)
+
+        assert data is not None and (isinstance(data, (pd.DataFrame, np.ndarray, xp.ndarray))), (
+            "DataFrame or numpy array required."
+        )
+
+        # convert dataframes to numpy arrays
+        if isinstance(data, pd.DataFrame):
+            data = data.to_numpy()
+
+        # check that data is float
+        if data.dtype not in [  # type: ignore
+            np.float32,
+            np.float64,
+            xp.float32,
+            xp.float64,
+        ]:
+            warnings.warn(
+                "Data does not appear to be a numpy/cupy float, casting to numpy float32.",
+                UserWarning,
+                stacklevel=2,
+            )
+            data = np.float32(data if isinstance(data, np.ndarray) else data.get())  # type: ignore
+
+        return method(self, data, *args, **kwargs) if self is not None else method(data, *args, **kwargs)
+
+    wrapper.__doc__ = method.__doc__
+    return wrapper

spatiomic/_internal/_get_neighbor_finder.py

@@ -0,0 +1,76 @@
+"""Get a nearest neighbor finder."""
+
+from typing import Callable, Literal, Union
+from warnings import warn
+
+from scipy.spatial.distance import correlation, cosine
+from sklearn.neighbors import NearestNeighbors as NearestNeighborsSk
+
+
+def get_neighbor_finder(
+    neighbor_count: int,
+    channel_count: int,
+    distance_metric: Literal["euclidean", "manhattan", "correlation", "cosine"] = "euclidean",
+    accuracy: Literal["fast", "accurate"] = "accurate",
+    job_count: int = -1,
+    use_gpu: bool = True,
+) -> NearestNeighborsSk:
+    """Get the nearest neighbor finder.
+
+    Args:
+        neighbor_count (int): The neighbor count for the neighborhood graph.
+        channel_count (int): The number of channels in the data.
+        distance_metric (Literal["euclidean", "manhattan", "correlation", "cosine"], optional): The distance metric
+            to be used for nearest neighbor calculation. Defaults to "euclidean".
+        accuracy (Literal["fast", "accurate"], optional): The accuracy of the nearest neighbor calculation. Used
+            only when method is `simple` or `batch_balanced`. Defaults to "accurate".
+        job_count (int, optional): Parallelization core count when method is `simple`. Defaults to -1.
+        use_gpu (bool, optional): Whether to use the GPU for nearest neighbor calculation if possible.
+            Defaults to True.
+
+    Returns:
+        Union[NearestNeighborsSk, Callable]: The nearest neighbor finder.
+    """
+    if use_gpu:
+        try:
+            from cuml.neighbors import NearestNeighbors  # type: ignore
+        except Exception:
+            warn(
+                "Could not import cuml implementation. Switching to non-GPU implementation.", UserWarning, stacklevel=2
+            )
+            use_gpu = False
+
+    if use_gpu:
+        if distance_metric != "euclidean" and accuracy == "fast" and channel_count <= 3:
+            warn(
+                "The fast accuracy setting is not available for the specified distance metric and data shape."
+                + " Falling back to the accurate setting.",
+                UserWarning,
+                stacklevel=2,
+            )
+
+        neighbor_finder = NearestNeighbors(
+            n_neighbors=neighbor_count,
+            algorithm=(
+                "rbc" if distance_metric == "euclidean" and accuracy == "fast" and channel_count <= 3 else "brute"
+            ),
+            metric=distance_metric,
+            output_type="numpy",
+        )
+    else:
+        metric: Union[str, Callable] = distance_metric
+
+        if distance_metric == "correlation":
+            metric = correlation
+        elif distance_metric == "cosine":
+            metric = cosine
+
+        # neighbor fitting
+        neighbor_finder = NearestNeighborsSk(
+            n_neighbors=neighbor_count,
+            algorithm=("ball_tree" if accuracy == "fast" else "brute"),
+            metric=metric,
+            n_jobs=job_count,
+        )
+
+    return neighbor_finder

spatiomic/_internal/_import_package.py

@@ -0,0 +1,55 @@
+import importlib
+from types import ModuleType
+from typing import Callable, Optional, Tuple, Union
+
+
+def import_package(
+    package_name: str,
+    package_attribute: Optional[str] = None,
+    alternative: Optional[ModuleType] = None,
+    message: Optional[str] = None,
+    raise_error: bool = True,
+    return_success: bool = False,
+) -> Optional[Union[Union[ModuleType, Callable], Tuple[Optional[Union[ModuleType, Callable]], bool]]]:
+    """Import a package, if it fails, return an alternative and state that an alternative is being used.
+
+    If no alternative is provided, raise an error, informing the user of the missing package.
+
+    Args:
+        package_name (str): The name of the package to import. May be a submodule, e.g. "numpy.random".
+        package_attribute (Optional[str], optional): The attribute of the package to return, e.g., a function or class.
+            Defaults to None.
+        alternative (ModuleType): The alternative to use if the package cannot be imported. Defaults to None.
+        message (Optional[str], optional): The message to print if the package cannot be imported. Defaults to None.
+        raise_error (bool, optional): Whether to raise an error if the package cannot be imported and no alternative is
+            provided. Defaults to True.
+        return_success (bool, optional): Whether to return a boolean indicating whether the import was successful.
+            Defaults to False.
+
+    Returns:
+        Union[Union[ModuleType, Callable], Tuple[Union[ModuleType, Callable], bool]]: The imported package, or the
+            alternative if the package could not be imported. If return_success is True, also returns a boolean
+            indicating whether the import was successful.
+
+    Raises:
+        ImportError: If the package cannot be imported and no alternative is provided.
+    """
+    try:
+        package = importlib.import_module(package_name)
+
+        if package_attribute is not None:
+            package = getattr(package, package_attribute)
+    except ImportError as excp:
+        if alternative is not None:
+            if message is not None:
+                print(message)
+
+            return alternative if not return_success else (alternative, False)
+        elif raise_error:
+            raise ImportError(
+                f"Could not import {package_name}. Please install it in order to use this functionality."
+            ) from excp
+        else:
+            return None if not return_success else (None, False)
+    else:
+        return package if not return_success else (package, True)

spatiomic/_internal/_seed_method.py

@@ -0,0 +1,64 @@
+import inspect
+import random
+from functools import wraps
+from typing import Any, Callable, Optional
+
+import numpy as np
+
+
+def seed_method(method: Callable) -> Callable:
+    """Set the `numpy` and `random` random states to a provided seed and reverts it after method execution.
+
+    Args:
+        method (Callable): The method to be invoked after setting the random state.
+
+    Returns:
+        Callable: The wrapper function that invokes the method.
+    """
+
+    @wraps(method)
+    def wrapper(
+        *args: Any,
+        **kwargs: dict,
+    ) -> Any:
+        """Set the `numpy` and `random` random states to a provided seed and reverts it after method execution.
+
+        Args:
+            ref (object): The reference to the object containing the decorated method.
+
+        Returns:
+            Any: The result of the invoked method.
+        """
+        # Check if 'self' is present as an argument
+        method_signature = inspect.signature(method)
+        parameters = method_signature.parameters
+
+        has_self = "self" in parameters
+
+        if has_self:
+            self_index = list(parameters.keys()).index("self")
+            self = args[self_index]
+            args = args[:self_index] + args[self_index + 1 :]
+        else:
+            self = None
+
+        seed: Optional[int] = kwargs["seed"] if "seed" in kwargs and isinstance(kwargs["seed"], int) else None
+
+        random_state_np = np.random.get_state()
+        random_state_sys = random.getstate()
+
+        if seed is not None:
+            np.random.seed(seed)
+            random.seed(seed)
+
+        result = method(self, *args, **kwargs) if self is not None else method(*args, **kwargs)
+
+        # reset the state
+        if seed is not None:
+            np.random.set_state(random_state_np)
+            random.setstate(random_state_sys)
+
+        return result
+
+    wrapper.__doc__ = method.__doc__
+    return wrapper

spatiomic/_version.py

@@ -0,0 +1,4 @@
+"""Version information for the spatiomic package."""
+
+# This package will follow Semantic Versioning after version 1.0.0: https://semver.org/
+__version__ = "0.4.0"

spatiomic/cluster/__init__.py

@@ -0,0 +1,15 @@
+"""Make all clustering classes available in the cluster submodule."""
+
+from spatiomic.dimension._som import Som as som
+
+from ._agglomerative import Agglomerative as agglomerative
+from ._kmeans import KMeans as kmeans
+from ._leiden import Leiden as leiden
+
+__all__ = [
+    "agglomerative",
+    "biclustering",
+    "kmeans",
+    "leiden",
+    "som",
+]