lamindb 0.69.8__py3-none-any.whl → 0.69.10__py3-none-any.whl

lamindb/core/_feature_manager.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from itertools import compress
-from typing import TYPE_CHECKING, Iterable
+from typing import TYPE_CHECKING, Iterable, Optional
 
 import anndata as ad
 from anndata import AnnData
@@ -23,7 +23,7 @@ from lamindb.core.storage import LocalPathClasses
 from ._settings import settings
 
 if TYPE_CHECKING:
-    from lnschema_core.types import AnnDataLike, FieldAttr
+    from lnschema_core.types import FieldAttr
 
     from lamindb._query_set import QuerySet
 
@@ -132,10 +132,11 @@ def print_features(self: Data) -> str:
 
 
 def parse_feature_sets_from_anndata(
-    adata: AnnDataLike,
-    var_field: FieldAttr,
+    adata: AnnData,
+    var_field: FieldAttr | None = None,
     obs_field: FieldAttr = Feature.name,
-    **kwargs,
+    mute: bool = False,
+    organism: str | Registry | None = None,
 ) -> dict:
     data_parse = adata
     if not isinstance(adata, AnnData):  # is a path
@@ -149,29 +150,36 @@ def parse_feature_sets_from_anndata(
             data_parse = ad.read(filepath, backed="r")
         type = "float"
     else:
-        type = convert_numpy_dtype_to_lamin_feature_type(adata.X.dtype)
+        type = (
+            "float"
+            if adata.X is None
+            else convert_numpy_dtype_to_lamin_feature_type(adata.X.dtype)
+        )
     feature_sets = {}
-    logger.info("parsing feature names of X stored in slot 'var'")
-    logger.indent = "   "
-    feature_set_var = FeatureSet.from_values(
-        data_parse.var.index,
-        var_field,
-        type=type,
-        **kwargs,
-    )
-    if feature_set_var is not None:
-        feature_sets["var"] = feature_set_var
-        logger.save(f"linked: {feature_set_var}")
-    logger.indent = ""
-    if feature_set_var is None:
-        logger.warning("skip linking features to artifact in slot 'var'")
+    if var_field is not None:
+        logger.info("parsing feature names of X stored in slot 'var'")
+        logger.indent = "   "
+        feature_set_var = FeatureSet.from_values(
+            data_parse.var.index,
+            var_field,
+            type=type,
+            mute=mute,
+            organism=organism,
+        )
+        if feature_set_var is not None:
+            feature_sets["var"] = feature_set_var
+            logger.save(f"linked: {feature_set_var}")
+        logger.indent = ""
+        if feature_set_var is None:
+            logger.warning("skip linking features to artifact in slot 'var'")
     if len(data_parse.obs.columns) > 0:
         logger.info("parsing feature names of slot 'obs'")
         logger.indent = "   "
         feature_set_obs = FeatureSet.from_df(
             df=data_parse.obs,
             field=obs_field,
-            **kwargs,
+            mute=mute,
+            organism=organism,
         )
         if feature_set_obs is not None:
             feature_sets["obs"] = feature_set_obs
@@ -224,7 +232,7 @@ class FeatureManager:
             slot = "columns" if slot is None else slot
         self._add_feature_set(feature_set=FeatureSet(features=features), slot=slot)
 
-    def add_from_df(self, field: FieldAttr = Feature.name, **kwargs):
+    def add_from_df(self, field: FieldAttr = Feature.name, organism: str | None = None):
         """Add features from DataFrame."""
         if isinstance(self._host, Artifact):
             assert self._host.accessor == "DataFrame"
@@ -235,7 +243,7 @@ class FeatureManager:
         # parse and register features
         registry = field.field.model
         df = self._host.load()
-        features = registry.from_values(df.columns, field=field, **kwargs)
+        features = registry.from_values(df.columns, field=field, organism=organism)
         if len(features) == 0:
             logger.error(
                 "no validated features found in DataFrame! please register features first!"
@@ -252,7 +260,8 @@ class FeatureManager:
         self,
         var_field: FieldAttr,
         obs_field: FieldAttr | None = Feature.name,
-        **kwargs,
+        mute: bool = False,
+        organism: str | Registry | None = None,
     ):
         """Add features from AnnData."""
         if isinstance(self._host, Artifact):
@@ -263,13 +272,53 @@ class FeatureManager:
         # parse and register features
         adata = self._host.load()
         feature_sets = parse_feature_sets_from_anndata(
-            adata, var_field=var_field, obs_field=obs_field, **kwargs
+            adata,
+            var_field=var_field,
+            obs_field=obs_field,
+            mute=mute,
+            organism=organism,
         )
 
         # link feature sets
         self._host._feature_sets = feature_sets
         self._host.save()
 
+    def add_from_mudata(
+        self,
+        var_fields: dict[str, FieldAttr],
+        obs_fields: dict[str, FieldAttr] = None,
+        mute: bool = False,
+        organism: str | Registry | None = None,
+    ):
+        """Add features from MuData."""
+        if obs_fields is None:
+            obs_fields = {}
+        if isinstance(self._host, Artifact):
+            assert self._host.accessor == "MuData"
+        else:
+            raise NotImplementedError()
+
+        # parse and register features
+        mdata = self._host.load()
+        feature_sets = {}
+        obs_features = features = Feature.from_values(mdata.obs.columns)
+        if len(obs_features) > 0:
+            feature_sets["obs"] = FeatureSet(features=features)
+        for modality, field in var_fields.items():
+            modality_fs = parse_feature_sets_from_anndata(
+                mdata[modality],
+                var_field=field,
+                obs_field=obs_fields.get(modality, Feature.name),
+                mute=mute,
+                organism=organism,
+            )
+            for k, v in modality_fs.items():
+                feature_sets[f"['{modality}'].{k}"] = v
+
+        # link feature sets
+        self._host._feature_sets = feature_sets
+        self._host.save()
+
     def _add_feature_set(self, feature_set: FeatureSet, slot: str):
         """Add new feature set to a slot.
 

lamindb/core/_label_manager.py

@@ -49,7 +49,7 @@ def print_labels(self: Data):
             n = labels.count()
             field = get_default_str_field(labels)
             print_values = _print_values(labels.list(field), n=10)
-            labels_msg += f"  🏷️ {related_name} ({n}, {colors.italic(related_model)}): {print_values}\n"
+            labels_msg += f"  📎 {related_name} ({n}, {colors.italic(related_model)}): {print_values}\n"
     if len(labels_msg) > 0:
         return f"{colors.green('Labels')}:\n{labels_msg}"
     else:

lamindb/core/_mapped_collection.py

@@ -11,7 +11,9 @@ from lamin_utils import logger
 from lamindb_setup.core.upath import UPath
 
 from .storage._backed_access import (
+    ArrayType,
     ArrayTypes,
+    GroupType,
     GroupTypes,
     StorageType,
     _safer_read_index,
@@ -55,6 +57,12 @@ class MappedCollection:
     If your `AnnData` collection is in the cloud, move them into a local cache
     first for faster access.
 
+    `__getitem__` of the `MappedCollection` object takes a single integer index
+    and returns a dictionary with the observation data sample for this index from
+    the `AnnData` objects in `path_list`. The dictionary has keys for `layers_keys`
+    (`.X` is in `"X"`), `obs_keys`, `obsm_keys` (under `f"obsm_{key}"`) and also `"_store_idx"`
+    for the index of the `AnnData` object containing this observation sample.
+
     .. note::
 
         For a guide, see :doc:`docs:scrna5`.
@@ -70,23 +78,28 @@ class MappedCollection:
 
     Args:
         path_list: A list of paths to `AnnData` objects stored in `.h5ad` or `.zarr` formats.
-        label_keys: Columns of the ``.obs`` slot that store labels.
+        layers_keys: Keys from the ``.layers`` slot. ``layers_keys=None`` or ``"X"`` in the list
+            retrieves ``.X``.
+        obsm_keys: Keys from the ``.obsm`` slots.
+        obs_keys: Keys from the ``.obs`` slots.
         join: `"inner"` or `"outer"` virtual joins. If ``None`` is passed,
             does not join.
         encode_labels: Encode labels into integers.
-            Can be a list with elements from ``label_keys```.
+            Can be a list with elements from ``obs_keys``.
         unknown_label: Encode this label to -1.
-            Can be a dictionary with keys from ``label_keys`` if ``encode_labels=True```
+            Can be a dictionary with keys from ``obs_keys`` if ``encode_labels=True``
             or from ``encode_labels`` if it is a list.
-        cache_categories: Enable caching categories of ``label_keys`` for faster access.
+        cache_categories: Enable caching categories of ``obs_keys`` for faster access.
         parallel: Enable sampling with multiple processes.
-        dtype: Convert numpy arrays from ``.X`` to this dtype on selection.
+        dtype: Convert numpy arrays from ``.X``, ``.layers`` and ``.obsm``
     """
 
     def __init__(
         self,
         path_list: list[UPathStr],
-        label_keys: str | list[str] | None = None,
+        layers_keys: str | list[str] | None = None,
+        obs_keys: str | list[str] | None = None,
+        obsm_keys: str | list[str] | None = None,
         join: Literal["inner", "outer"] | None = "inner",
         encode_labels: bool | list[str] = True,
         unknown_label: str | dict[str, str] | None = None,
@@ -96,27 +109,37 @@ class MappedCollection:
     ):
         assert join in {None, "inner", "outer"}
 
-        label_keys = [label_keys] if isinstance(label_keys, str) else label_keys
-        self.label_keys = label_keys
+        if layers_keys is None:
+            self.layers_keys = ["X"]
+        else:
+            self.layers_keys = (
+                [layers_keys] if isinstance(layers_keys, str) else layers_keys
+            )
+
+        obsm_keys = [obsm_keys] if isinstance(obsm_keys, str) else obsm_keys
+        self.obsm_keys = obsm_keys
+
+        obs_keys = [obs_keys] if isinstance(obs_keys, str) else obs_keys
+        self.obs_keys = obs_keys
 
         if isinstance(encode_labels, list):
             if len(encode_labels) == 0:
                 encode_labels = False
-            elif label_keys is None or not all(
-                enc_label in label_keys for enc_label in encode_labels
+            elif obs_keys is None or not all(
+                enc_label in obs_keys for enc_label in encode_labels
             ):
                 raise ValueError(
-                    "All elements of `encode_labels` should be in `label_keys`."
+                    "All elements of `encode_labels` should be in `obs_keys`."
                 )
         else:
             if encode_labels:
-                encode_labels = label_keys if label_keys is not None else False
+                encode_labels = obs_keys if obs_keys is not None else False
         self.encode_labels = encode_labels
 
         if encode_labels and isinstance(unknown_label, dict):
             if not all(unkey in encode_labels for unkey in unknown_label):  # type: ignore
                 raise ValueError(
-                    "All keys of `unknown_label` should be in `encode_labels` and `label_keys`."
+                    "All keys of `unknown_label` should be in `encode_labels` and `obs_keys`."
                 )
         self.unknown_label = unknown_label
 
@@ -141,12 +164,16 @@ class MappedCollection:
 
         self.join_vars = join
         self.var_indices = None
+        self.var_joint = None
+        self.n_vars_list = None
+        self.n_vars = None
         if self.join_vars is not None:
             self._make_join_vars()
+            self.n_vars = len(self.var_joint)
 
-        if self.label_keys is not None:
+        if self.obs_keys is not None:
             if cache_categories:
-                self._cache_categories(self.label_keys)
+                self._cache_categories(self.obs_keys)
             else:
                 self._cache_cats: dict = {}
             self.encoders: dict = {}
@@ -169,10 +196,10 @@ class MappedCollection:
             self.conns.append(conn)
             self.storages.append(storage)
 
-    def _cache_categories(self, label_keys: list):
+    def _cache_categories(self, obs_keys: list):
         self._cache_cats = {}
         decode = np.frompyfunc(lambda x: x.decode("utf-8"), 1, 1)
-        for label in label_keys:
+        for label in obs_keys:
             self._cache_cats[label] = []
             for storage in self.storages:
                 with _Connect(storage) as store:
@@ -197,11 +224,13 @@ class MappedCollection:
 
     def _make_join_vars(self):
         var_list = []
+        self.n_vars_list = []
         for storage in self.storages:
             with _Connect(storage) as store:
-                var_list.append(_safer_read_index(store["var"]))
+                vars = _safer_read_index(store["var"])
+                var_list.append(vars)
+                self.n_vars_list.append(len(vars))
 
-        self.var_joint = None
         vars_eq = all(var_list[0].equals(vrs) for vrs in var_list[1:])
         if vars_eq:
             self.join_vars = None
@@ -223,6 +252,20 @@ class MappedCollection:
     def __len__(self):
         return self.n_obs
 
+    @property
+    def shape(self):
+        """Shape of the (virtually aligned) dataset."""
+        return (self.n_obs, self.n_vars)
+
+    @property
+    def original_shapes(self):
+        """Shapes of the underlying AnnData objects."""
+        if self.n_vars_list is None:
+            n_vars_list = [None] * len(self.n_obs_list)
+        else:
+            n_vars_list = self.n_vars_list
+        return list(zip(self.n_obs_list, n_vars_list))
+
     def __getitem__(self, idx: int):
         obs_idx = self.indices[idx]
         storage_idx = self.storage_idx[idx]
@@ -232,17 +275,28 @@ class MappedCollection:
             var_idxs_join = None
 
         with _Connect(self.storages[storage_idx]) as store:
-            out = {"x": self._get_data_idx(store, obs_idx, var_idxs_join)}
-            out["_storage_idx"] = storage_idx
-            if self.label_keys is not None:
-                for label in self.label_keys:
+            out = {}
+            for layers_key in self.layers_keys:
+                lazy_data = (
+                    store["X"] if layers_key == "X" else store["layers"][layers_key]
+                )
+                out[layers_key] = self._get_data_idx(
+                    lazy_data, obs_idx, self.join_vars, var_idxs_join, self.n_vars
+                )
+            if self.obsm_keys is not None:
+                for obsm_key in self.obsm_keys:
+                    lazy_data = store["obsm"][obsm_key]
+                    out[f"obsm_{obsm_key}"] = self._get_data_idx(lazy_data, obs_idx)
+            out["_store_idx"] = storage_idx
+            if self.obs_keys is not None:
+                for label in self.obs_keys:
                     if label in self._cache_cats:
                         cats = self._cache_cats[label][storage_idx]
                         if cats is None:
                             cats = []
                     else:
                         cats = None
-                    label_idx = self._get_label_idx(store, obs_idx, label, cats)
+                    label_idx = self._get_obs_idx(store, obs_idx, label, cats)
                     if label in self.encoders:
                         label_idx = self.encoders[label][label_idx]
                     out[label] = label_idx
@@ -250,46 +304,46 @@ class MappedCollection:
 
     def _get_data_idx(
         self,
-        storage: StorageType,  # type: ignore
+        lazy_data: ArrayType | GroupType,  # type: ignore
         idx: int,
+        join_vars: Literal["inner", "outer"] | None = None,
         var_idxs_join: list | None = None,
-        layer_key: str | None = None,
+        n_vars_out: int | None = None,
     ):
         """Get the index for the data."""
-        layer = storage["X"] if layer_key is None else storage["layers"][layer_key]  # type: ignore
-        if isinstance(layer, ArrayTypes):  # type: ignore
-            layer_idx = layer[idx]
-            if self.join_vars is None:
-                result = layer_idx
+        if isinstance(lazy_data, ArrayTypes):  # type: ignore
+            lazy_data_idx = lazy_data[idx]  # type: ignore
+            if join_vars is None:
+                result = lazy_data_idx
                 if self._dtype is not None:
                     result = result.astype(self._dtype, copy=False)
-            elif self.join_vars == "outer":
-                dtype = layer_idx.dtype if self._dtype is None else self._dtype
-                result = np.zeros(len(self.var_joint), dtype=dtype)
-                result[var_idxs_join] = layer_idx
+            elif join_vars == "outer":
+                dtype = lazy_data_idx.dtype if self._dtype is None else self._dtype
+                result = np.zeros(n_vars_out, dtype=dtype)
+                result[var_idxs_join] = lazy_data_idx
             else:  # inner join
-                result = layer_idx[var_idxs_join]
+                result = lazy_data_idx[var_idxs_join]
                 if self._dtype is not None:
                     result = result.astype(self._dtype, copy=False)
             return result
         else:  # assume csr_matrix here
-            data = layer["data"]
-            indices = layer["indices"]
-            indptr = layer["indptr"]
+            data = lazy_data["data"]  # type: ignore
+            indices = lazy_data["indices"]  # type: ignore
+            indptr = lazy_data["indptr"]  # type: ignore
             s = slice(*(indptr[idx : idx + 2]))
             data_s = data[s]
             dtype = data_s.dtype if self._dtype is None else self._dtype
-            if self.join_vars == "outer":
-                layer_idx = np.zeros(len(self.var_joint), dtype=dtype)
-                layer_idx[var_idxs_join[indices[s]]] = data_s
+            if join_vars == "outer":
+                lazy_data_idx = np.zeros(n_vars_out, dtype=dtype)
+                lazy_data_idx[var_idxs_join[indices[s]]] = data_s
             else:
-                layer_idx = np.zeros(layer.attrs["shape"][1], dtype=dtype)
-                layer_idx[indices[s]] = data_s
-                if self.join_vars == "inner":
-                    layer_idx = layer_idx[var_idxs_join]
-            return layer_idx
+                lazy_data_idx = np.zeros(lazy_data.attrs["shape"][1], dtype=dtype)  # type: ignore
+                lazy_data_idx[indices[s]] = data_s
+                if join_vars == "inner":
+                    lazy_data_idx = lazy_data_idx[var_idxs_join]
+            return lazy_data_idx
 
-    def _get_label_idx(
+    def _get_obs_idx(
         self,
         storage: StorageType,
         idx: int,
@@ -317,12 +371,12 @@ class MappedCollection:
             label = label.decode("utf-8")
         return label
 
-    def get_label_weights(self, label_keys: str | list[str]):
+    def get_label_weights(self, obs_keys: str | list[str]):
         """Get all weights for the given label keys."""
-        if isinstance(label_keys, str):
-            label_keys = [label_keys]
+        if isinstance(obs_keys, str):
+            obs_keys = [obs_keys]
         labels_list = []
-        for label_key in label_keys:
+        for label_key in obs_keys:
             labels_to_str = self.get_merged_labels(label_key).astype(str).astype("O")
             labels_list.append(labels_to_str)
         if len(labels_list) > 1:

lamindb/core/datasets/_core.py

@@ -401,7 +401,47 @@ def mudata_papalexi21_subset():  # pragma: no cover
         "papalexi21_subset.h5mu",
     )
 
-    return md.read_h5mu(filepath)
+    mdata = md.read_h5mu(filepath)
+    for mod in ["rna", "adt", "hto", "gdo"]:
+        mdata[mod].obs.drop(
+            mdata[mod].obs.columns, axis=1, inplace=True
+        )  # Drop all columns
+    for col in mdata.obs.columns:
+        for mod in ["rna", "adt", "hto", "gdo"]:
+            if col.endswith(f"_{mod.upper()}"):
+                new_col = col.replace(f"{mod}:", "")
+                if new_col != col:
+                    mdata[mod].obs[new_col] = mdata.obs.pop(col)
+            else:
+                new_col = col.replace(f"{mod}:", "")
+                if new_col not in mdata.obs.columns and col in mdata.obs.columns:
+                    mdata.obs[new_col] = mdata.obs.pop(col)
+
+    for col in mdata.obs.columns:
+        for mod in ["rna", "adt", "hto", "gdo"]:
+            if col.endswith(f"_{mod.upper()}"):
+                del mdata.obs[col]
+
+    for col in [
+        "orig.ident",
+        "MULTI_ID",
+        "NT",
+        "S.Score",
+        "G2M.Score",
+        "Phase",
+        "gene_target",
+        "guide_ID",
+        "HTO_classification",
+    ]:
+        del mdata.obs[col]
+        mdata.update()
+
+    mdata["rna"].obs["percent.mito"] = mdata.obs.pop("percent.mito")
+    mdata["hto"].obs["technique"] = "cell hashing"
+    mdata["hto"].obs["technique"] = mdata["hto"].obs["technique"].astype("category")
+    mdata.update()
+
+    return mdata
 
 
 def df_iris() -> pd.DataFrame:

lamindb/core/storage/_backed_access.py

@@ -100,7 +100,7 @@ def _records_to_df(obj):
         return obj
 
 
-class Registry:
+class AccessRegistry:
     def __init__(self):
         self._registry = {}
         self._openers = {}
@@ -141,7 +141,7 @@ class Registry:
 
 
 # storage specific functions should be registered and called through the registry
-registry = Registry()
+registry = AccessRegistry()
 
 
 @registry.register_open("h5py")
@@ -176,8 +176,12 @@ def safer_read_partial(elem, indices):
         indices_increasing = []
         indices_inverse = []
         for indices_dim in indices:
-            if isinstance(indices_dim, np.ndarray) and not np.all(
-                np.diff(indices_dim) > 0
+            # should be integer or bool
+            # ignore bool or increasing unique integers
+            if (
+                isinstance(indices_dim, np.ndarray)
+                and indices_dim.dtype != "bool"
+                and not np.all(np.diff(indices_dim) > 0)
             ):
                 idx_unique, idx_inverse = np.unique(indices_dim, return_inverse=True)
                 indices_increasing.append(idx_unique)

lamindb/core/storage/file.py

@@ -22,6 +22,7 @@ from lnschema_core.models import Artifact, Storage
 from lamindb.core._settings import settings
 
 if TYPE_CHECKING:
+    import mudata as md
     from lamindb_setup.core.types import UPathStr
 
 try:
@@ -136,6 +137,9 @@ def delete_storage_using_key(
 
 def delete_storage(storagepath: Path):
     """Delete arbitrary artifact."""
+    # TODO is_relative_to is not available in 3.8 and deprecated since 3.12
+    # replace with check_path_is_child_of_root but this needs to first be debugged
+    # if not check_path_is_child_of_root(storagepath, settings.storage):
     if not storagepath.is_relative_to(settings.storage):  # type: ignore
         logger.warning("couldn't delete files outside of default storage")
         return "did-not-delete"
@@ -167,6 +171,13 @@ def read_tsv(path: UPathStr, **kwargs) -> pd.DataFrame:
     return pd.read_csv(path_sanitized, sep="\t", **kwargs)
 
 
+def read_mdata_h5mu(filepath: UPathStr, **kwargs) -> md.MuData:
+    import mudata as md
+
+    path_sanitized = Path(filepath)
+    return md.read_h5mu(path_sanitized, **kwargs)
+
+
 def load_html(path: UPathStr):
     if is_run_from_ipython:
         with open(path, encoding="utf-8") as f:
@@ -221,6 +232,7 @@ def load_to_memory(filepath: UPathStr, stream: bool = False, **kwargs):
         ".zrad": read_adata_zarr,
         ".html": load_html,
         ".json": load_json,
+        ".h5mu": read_mdata_h5mu,
     }
 
     reader = READER_FUNCS.get(filepath.suffix)

lamindb/core/storage/object.py

@@ -9,6 +9,14 @@ if TYPE_CHECKING:
     from lamindb_setup.core.types import UPathStr
 
 
+def _mudata_is_installed():
+    try:
+        import mudata
+    except ImportError:
+        return False
+    return True
+
+
 def infer_suffix(dmem, adata_format: str | None = None):
     """Infer LaminDB storage file suffix from a data object."""
     if isinstance(dmem, AnnData):
@@ -25,6 +33,11 @@ def infer_suffix(dmem, adata_format: str | None = None):
     elif isinstance(dmem, DataFrame):
         return ".parquet"
     else:
+        if _mudata_is_installed():
+            from mudata import MuData
+
+            if isinstance(dmem, MuData):
+                return ".h5mu"
         raise NotImplementedError
 
 
@@ -34,4 +47,10 @@ def write_to_file(dmem, filepath: UPathStr):
     elif isinstance(dmem, DataFrame):
         dmem.to_parquet(filepath)
     else:
+        if _mudata_is_installed():
+            from mudata import MuData
+
+            if isinstance(dmem, MuData):
+                dmem.write(filepath)
+                return
         raise NotImplementedError

lamindb/core/types.py

@@ -4,14 +4,12 @@
    :toctree: .
 
    UPathStr
-   DataLike
    StrField
    ListLike
    TransformType
 """
 from lamindb_setup.core.types import UPathStr
 from lnschema_core.types import (
-    DataLike,
     ListLike,
     StrField,
     TransformType,

lamindb/setup/core/__init__.py

@@ -1,15 +1,4 @@
-"""Core setup library.
+import lamindb_setup as _lamindb_setup
+from lamindb_setup.core import *  # noqa: F403
 
-.. autosummary::
-   :toctree:
-
-   UserSettings
-   InstanceSettings
-   StorageSettings
-
-"""
-from lamindb_setup.core import (  # pragma: no cover
-    InstanceSettings,
-    StorageSettings,
-    UserSettings,
-)
+__doc__ = _lamindb_setup.core.__doc__.replace("lamindb_setup", "lamindb.setup")