lamindb 0.77.2__py3-none-any.whl → 0.77.4__py3-none-any.whl

lamindb/_finish.py

@@ -18,8 +18,8 @@ if TYPE_CHECKING:
     from ._query_set import QuerySet
 
 
-def get_r_save_notebook_message() -> str:
-    return f"Please save the notebook in RStudio (shortcut `{get_shortcut()}`) within 2 sec before calling `db$finish()`"
+def get_save_notebook_message() -> str:
+    return f"Please save the notebook in your editor (shortcut `{get_shortcut()}`) within 2 sec before calling `finish()`"
 
 
 def get_shortcut() -> str:
@@ -114,7 +114,7 @@ def clean_r_notebook_html(file_path: Path) -> tuple[str | None, Path]:
         cleaned_content = re.sub(pattern_title, "", cleaned_content)
         cleaned_content = re.sub(pattern_h1, "", cleaned_content)
     cleaned_content = cleaned_content.replace(
-        f"NotebookNotSaved: {get_r_save_notebook_message()}", ""
+        f"NotebookNotSaved: {get_save_notebook_message()}", ""
     )
     cleaned_path = file_path.parent / (f"{file_path.stem}.cleaned{file_path.suffix}")
     cleaned_path.write_text(cleaned_content)
@@ -189,6 +189,10 @@ def save_context_core(
             logger.warning(
                 f"no {filepath.with_suffix('.nb.html')} found, save your manually rendered .html report via the CLI: lamin save {filepath}"
             )
+    if report_path is not None and not from_cli:
+        if get_seconds_since_modified(report_path) > 2 and not ln_setup._TESTING:
+            # this can happen when auto-knitting an html with RStudio
+            raise NotebookNotSaved(get_save_notebook_message())
     ln.settings.creation.artifact_silence_missing_run_warning = True
     # track source code
     hash, _ = hash_file(source_code_path)  # ignore hash_type for now
@@ -249,10 +253,6 @@ def save_context_core(
 
     # track report and set is_consecutive
     if report_path is not None:
-        if not from_cli:
-            if get_seconds_since_modified(report_path) > 2 and not ln_setup._TESTING:
-                # this can happen when auto-knitting an html with RStudio
-                raise NotebookNotSaved(get_r_save_notebook_message())
         if is_r_notebook:
             title_text, report_path = clean_r_notebook_html(report_path)
             if title_text is not None:

lamindb/_from_values.py

@@ -95,7 +95,7 @@ def get_or_create_records(
                 if len(msg) > 0 and not mute:
                     logger.success(msg)
                 s = "" if len(unmapped_values) == 1 else "s"
-                print_values = colors.yellow(_print_values(unmapped_values))
+                print_values = colors.yellow(_format_values(unmapped_values))
                 name = registry.__name__
                 n_nonval = colors.yellow(f"{len(unmapped_values)} non-validated")
                 if not mute:
@@ -167,7 +167,7 @@ def get_existing_records(
     if not mute:
         if len(validated) > 0:
             s = "" if len(validated) == 1 else "s"
-            print_values = colors.green(_print_values(validated))
+            print_values = colors.green(_format_values(validated))
             msg = (
                 "loaded"
                 f" {colors.green(f'{len(validated)} {model.__name__} record{s}')}"
@@ -176,7 +176,7 @@ def get_existing_records(
         if len(syn_mapper) > 0:
             s = "" if len(syn_mapper) == 1 else "s"
             names = list(syn_mapper.keys())
-            print_values = colors.green(_print_values(names))
+            print_values = colors.green(_format_values(names))
             syn_msg = (
                 "loaded"
                 f" {colors.green(f'{len(syn_mapper)} {model.__name__} record{s}')}"
@@ -243,7 +243,7 @@ def create_records_from_source(
     if len(syn_mapper) > 0:
         s = "" if len(syn_mapper) == 1 else "s"
         names = list(syn_mapper.keys())
-        print_values = colors.purple(_print_values(names))
+        print_values = colors.purple(_format_values(names))
         msg_syn = (
             "created"
             f" {colors.purple(f'{len(syn_mapper)} {model.__name__} record{s} from Bionty')}"
@@ -277,7 +277,7 @@ def create_records_from_source(
         validated = result.validated
         if len(validated) > 0:
             s = "" if len(validated) == 1 else "s"
-            print_values = colors.purple(_print_values(validated))
+            print_values = colors.purple(_format_values(validated))
             # this is the success msg for existing records in the DB
             if len(msg) > 0 and not mute:
                 logger.success(msg)
@@ -307,7 +307,7 @@ def index_iterable(iterable: Iterable) -> pd.Index:
     return idx[(idx != "") & (~idx.isnull())]
 
 
-def _print_values(
+def _format_values(
     names: Iterable, n: int = 20, quotes: bool = True, sep: str = "'"
 ) -> str:
     if isinstance(names, dict):
@@ -345,7 +345,7 @@ def _bulk_create_dicts_from_df(
         dup = df.index[df.index.duplicated()].unique().tolist()
         if len(dup) > 0:
             s = "" if len(dup) == 1 else "s"
-            print_values = _print_values(dup)
+            print_values = _format_values(dup)
             multi_msg = (
                 f"ambiguous validation in Bionty for {len(dup)} record{s}:"
                 f" {print_values}"

lamindb/_record.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import builtins
+import re
 from functools import reduce
 from typing import TYPE_CHECKING, NamedTuple
 
@@ -316,6 +317,7 @@ def _search(
             string = string[:n_80_pct]
 
     string = string.strip()
+    string_escape = re.escape(string)
 
     exact_lookup = Exact if case_sensitive else IExact
     regex_lookup = Regex if case_sensitive else IRegex
@@ -334,28 +336,28 @@ def _search(
         exact_rank = Cast(exact_expr, output_field=IntegerField()) * 200
         ranks.append(exact_rank)
         # exact synonym
-        synonym_expr = regex_lookup(field_expr, rf"(?:^|.*\|){string}(?:\|.*|$)")
+        synonym_expr = regex_lookup(field_expr, rf"(?:^|.*\|){string_escape}(?:\|.*|$)")
         synonym_rank = Cast(synonym_expr, output_field=IntegerField()) * 200
         ranks.append(synonym_rank)
         # match as sub-phrase
         sub_expr = regex_lookup(
-            field_expr, rf"(?:^|.*[ \|\.,;:]){string}(?:[ \|\.,;:].*|$)"
+            field_expr, rf"(?:^|.*[ \|\.,;:]){string_escape}(?:[ \|\.,;:].*|$)"
         )
         sub_rank = Cast(sub_expr, output_field=IntegerField()) * 10
         ranks.append(sub_rank)
         # startswith and avoid matching string with " " on the right
         # mostly for truncated
         startswith_expr = regex_lookup(
-            field_expr, rf"(?:^|.*\|){string}[^ ]*(?:\|.*|$)"
+            field_expr, rf"(?:^|.*\|){string_escape}[^ ]*(?:\|.*|$)"
         )
         startswith_rank = Cast(startswith_expr, output_field=IntegerField()) * 8
         ranks.append(startswith_rank)
         # match as sub-phrase from the left, mostly for truncated
-        right_expr = regex_lookup(field_expr, rf"(?:^|.*[ \|]){string}.*")
+        right_expr = regex_lookup(field_expr, rf"(?:^|.*[ \|]){string_escape}.*")
         right_rank = Cast(right_expr, output_field=IntegerField()) * 2
         ranks.append(right_rank)
         # match as sub-phrase from the right
-        left_expr = regex_lookup(field_expr, rf".*{string}(?:$|[ \|\.,;:].*)")
+        left_expr = regex_lookup(field_expr, rf".*{string_escape}(?:$|[ \|\.,;:].*)")
         left_rank = Cast(left_expr, output_field=IntegerField()) * 2
         ranks.append(left_rank)
         # simple contains filter

lamindb/_save.py

@@ -184,10 +184,17 @@ def copy_or_move_to_cache(
         return None
     # non-local storage_path further
     if local_path != cache_path:
-        cache_path.parent.mkdir(parents=True, exist_ok=True)
-        if cache_dir in local_path.parents:
+        if cache_path.exists():
+            logger.warning(
+                f"The cache path {cache_path.as_posix()} already exists, replacing it."
+            )
             if cache_path.is_dir():
                 shutil.rmtree(cache_path)
+            else:
+                cache_path.unlink()
+        else:
+            cache_path.parent.mkdir(parents=True, exist_ok=True)
+        if cache_dir in local_path.parents:
             local_path.replace(cache_path)
         else:
             if is_dir:

lamindb/_view.py

@@ -5,7 +5,6 @@ import importlib
 import inspect
 from typing import TYPE_CHECKING
 
-from IPython.display import HTML, display
 from lamin_utils import colors, logger
 from lamindb_setup import settings
 from lamindb_setup._init_instance import get_schema_module_name
@@ -24,6 +23,8 @@ is_run_from_ipython = getattr(builtins, "__IPYTHON__", False)
 def display_df_with_descriptions(
     df: pd.DataFrame, descriptions: dict[str, str] | None = None
 ):
+    from IPython.display import HTML, display
+
     if descriptions is None:
         display(df)
         return None

lamindb/core/__init__.py

@@ -33,6 +33,7 @@ Curators:
    DataFrameCurator
    AnnDataCurator
    MuDataCurator
+   SOMACurator
    CurateLookup
 
 Settings & context:
@@ -86,6 +87,7 @@ from lamindb._curate import (
     CurateLookup,
     DataFrameCurator,
     MuDataCurator,
+    SOMACurator,
 )
 from lamindb._query_manager import QueryManager
 from lamindb._query_set import QuerySet, RecordList

lamindb/core/_context.py

@@ -580,8 +580,8 @@ class Context:
 
         """
         from lamindb._finish import (
+            get_save_notebook_message,
             get_seconds_since_modified,
-            get_shortcut,
             save_context_core,
         )
 
@@ -604,9 +604,7 @@ class Context:
                 self.transform.name = nbproject_title
                 self.transform.save()
             if get_seconds_since_modified(self._path) > 2 and not ln_setup._TESTING:
-                raise NotebookNotSaved(
-                    f"Please save the notebook in your editor (shortcut `{get_shortcut()}`) within 2 sec before calling `ln.finish()`"
-                )
+                raise NotebookNotSaved(get_save_notebook_message())
         save_context_core(
             run=self.run,
             transform=self.run.transform,

lamindb/core/_django.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from functools import reduce
+
 from django.contrib.postgres.aggregates import ArrayAgg
 from django.db import connection
 from django.db.models import F, OuterRef, Q, Subquery
@@ -81,15 +83,6 @@ def get_artifact_with_related(
                 id=F(f"{fk}__id"), name=F(f"{fk}__{name_field}")
             )
 
-    for name in m2m_relations:
-        related_model = get_related_model(model, name)
-        name_field = get_name_field(related_model)
-        annotations[f"m2mfield_{name}"] = ArrayAgg(
-            JSONObject(id=F(f"{name}__id"), name=F(f"{name}__{name_field}")),
-            filter=Q(**{f"{name}__isnull": False}),
-            distinct=True,
-        )
-
     for link in link_tables:
         link_model = getattr(model, link).rel.related_model
         if not hasattr(link_model, "feature"):
@@ -137,9 +130,7 @@ def get_artifact_with_related(
 
     related_data: dict = {"m2m": {}, "fk": {}, "link": {}, "featuresets": {}}
     for k, v in artifact_meta.items():
-        if k.startswith("m2mfield_"):
-            related_data["m2m"][k[9:]] = v
-        elif k.startswith("fkfield_"):
+        if k.startswith("fkfield_"):
             related_data["fk"][k[8:]] = v
         elif k.startswith("linkfield_"):
             related_data["link"][k[10:]] = v
@@ -149,11 +140,33 @@ def get_artifact_with_related(
                     artifact, {i["featureset"]: i["slot"] for i in v}
                 )
 
-    related_data["m2m"] = {
-        k: {item["id"]: item["name"] for item in v}
-        for k, v in related_data["m2m"].items()
-        if v
-    }
+    if len(m2m_relations) == 0:
+        m2m_any = False
+    else:
+        m2m_any_expr = reduce(
+            lambda a, b: a | b,
+            (Q(**{f"{m2m_name}__isnull": False}) for m2m_name in m2m_relations),
+        )
+        # this is needed to avoid querying all m2m relations even if they are all empty
+        # this checks if non-empty m2m relations are present in the record
+        m2m_any = (
+            model.objects.using(artifact._state.db)
+            .filter(uid=artifact.uid)
+            .filter(m2m_any_expr)
+            .exists()
+        )
+    if m2m_any:
+        m2m_data = related_data["m2m"]
+        for m2m_name in m2m_relations:
+            related_model = get_related_model(model, m2m_name)
+            name_field = get_name_field(related_model)
+            m2m_records = (
+                getattr(artifact, m2m_name).values_list("id", name_field).distinct()
+            )
+            for rec_id, rec_name in m2m_records:
+                if m2m_name not in m2m_data:
+                    m2m_data[m2m_name] = {}
+                m2m_data[m2m_name][rec_id] = rec_name
 
     return {
         **{name: artifact_meta[name] for name in ["id", "uid"]},

lamindb/core/_feature_manager.py

@@ -42,7 +42,7 @@ from lamindb._feature import (
     suggest_categorical_for_str_iterable,
 )
 from lamindb._feature_set import DICT_KEYS_TYPE, FeatureSet
-from lamindb._from_values import _print_values
+from lamindb._from_values import _format_values
 from lamindb._record import (
     REGISTRY_UNIQUE_FIELD,
     get_name_field,
@@ -282,13 +282,15 @@ def _get_featuresets_postgres(
     return fs_data
 
 
-def _create_feature_table(name: str, registry_str: str, data: list) -> Table:
+def _create_feature_table(
+    name: str, registry_str: str, data: list, show_header: bool = False
+) -> Table:
     """Create a Rich table for a feature group."""
     table = Table(
         Column(name, style="", no_wrap=True, width=NAME_WIDTH),
         Column(registry_str, style="dim", no_wrap=True, width=TYPE_WIDTH),
         Column("", width=VALUES_WIDTH, no_wrap=True),
-        show_header=True,
+        show_header=show_header,
         box=None,
         pad_edge=False,
     )
@@ -331,7 +333,7 @@ def describe_features(
             fs_data = _get_featuresets_postgres(self, related_data=related_data)
             for fs_id, (slot, data) in fs_data.items():
                 for registry_str, feature_names in data.items():
-                    feature_set = FeatureSet.get(id=fs_id)
+                    feature_set = FeatureSet.objects.using(self._state.db).get(id=fs_id)
                     feature_set_data[slot] = (feature_set, feature_names)
                     for feature_name in feature_names:
                         feature_data[feature_name] = (slot, registry_str)
@@ -345,15 +347,15 @@ def describe_features(
                 for feature_name in feature_names:
                     feature_data[feature_name] = (slot, feature_set.registry)
 
-    internal_feature_names: set[str] = {}  # type: ignore
+    internal_feature_names: dict[str, str] = {}
     if isinstance(self, Artifact):
         feature_sets = self.feature_sets.filter(registry="Feature").all()
-        internal_feature_names = set()  # type: ignore
+        internal_feature_names = {}
         if len(feature_sets) > 0:
             for feature_set in feature_sets:
-                internal_feature_names = internal_feature_names.union(
-                    set(feature_set.members.values_list("name", flat=True))
-                )  # type: ignore
+                internal_feature_names.update(
+                    dict(feature_set.members.values_list("name", "dtype"))
+                )
 
     # categorical feature values
     # Get the categorical data using the appropriate method
@@ -388,7 +390,7 @@ def describe_features(
 
             # Format message
             printed_values = (
-                _print_values(sorted(values), n=10, quotes=False)
+                _format_values(sorted(values), n=10, quotes=False)
                 if not is_list_type or not feature_dtype.startswith("list")
                 else sorted(values)
             )
@@ -407,25 +409,47 @@ def describe_features(
     if to_dict:
         return dictionary
 
-    # Dataset section
-    internal_features_slot: dict[
-        str, list
-    ] = {}  # internal features from the `Feature` registry that contain labels
+    # Dataset features section
+    # internal features that contain labels (only `Feature` features contain labels)
+    internal_feature_labels_slot: dict[str, list] = {}
     for feature_name, feature_row in internal_feature_labels.items():
         slot, _ = feature_data.get(feature_name)
-        internal_features_slot.setdefault(slot, []).append(feature_row)
-    dataset_tree_children = []
+        internal_feature_labels_slot.setdefault(slot, []).append(feature_row)
 
+    int_features_tree_children = []
     for slot, (feature_set, feature_names) in feature_set_data.items():
-        if slot in internal_features_slot:
-            feature_rows = internal_features_slot[slot]
+        if slot in internal_feature_labels_slot:
+            # add internal Feature features with labels
+            feature_rows = internal_feature_labels_slot[slot]
+            # add internal Feature features without labels
+            feature_rows += [
+                (
+                    feature_name,
+                    Text(str(internal_feature_names.get(feature_name)), style="dim"),
+                    "",
+                )
+                for feature_name in feature_names
+                if feature_name and feature_name not in internal_feature_labels
+            ]
         else:
+            # add internal non-Feature features without labels
             feature_rows = [
-                (feature_name, Text(str(feature_set.dtype), style="dim"), "")
+                (
+                    feature_name,
+                    Text(
+                        str(
+                            internal_feature_names.get(feature_name)
+                            if feature_name in internal_feature_names
+                            else feature_set.dtype
+                        ),
+                        style="dim",
+                    ),
+                    "",
+                )
                 for feature_name in feature_names
                 if feature_name
             ]
-        dataset_tree_children.append(
+        int_features_tree_children.append(
             _create_feature_table(
                 Text.assemble(
                     (slot, "violet"),
@@ -434,46 +458,45 @@ def describe_features(
                 ),
                 Text.assemble((f"[{feature_set.registry}]", "pink1")),
                 feature_rows,
+                show_header=True,
             )
         )
     ## internal features from the non-`Feature` registry
-    if dataset_tree_children:
+    if int_features_tree_children:
         dataset_tree = tree.add(
             Text.assemble(
-                ("Dataset", "bold bright_magenta"),
+                ("Dataset features", "bold bright_magenta"),
                 ("/", "dim"),
                 (".feature_sets", "dim bold"),
             )
         )
-        for child in dataset_tree_children:
+        for child in int_features_tree_children:
             dataset_tree.add(child)
 
-    # Annotations section
-    ## external features
-    features_tree_children = []
+    # Linked features
+    ext_features_tree_children = []
     if external_data:
-        features_tree_children.append(
+        ext_features_tree_children.append(
             _create_feature_table(
-                Text.assemble(
-                    ("Params" if print_params else "Features", "green_yellow")
-                ),
+                "",
                 "",
                 external_data,
             )
         )
-    annotations_tree = None
-    if features_tree_children:
-        annotations_tree = tree.add(Text("Annotations", style="bold dark_orange"))
-        for child in features_tree_children:
-            annotations_tree.add(child)
+    # ext_features_tree = None
+    ext_features_header = Text(
+        "Params" if print_params else "Linked features", style="bold dark_orange"
+    )
+    if ext_features_tree_children:
+        ext_features_tree = tree.add(ext_features_header)
+        for child in ext_features_tree_children:
+            ext_features_tree.add(child)
     if with_labels:
-        labels_tree = describe_labels(self, as_subtree=True)
+        # avoid querying the db if the labels were queried already
+        labels_data = related_data.get("m2m") if related_data is not None else None
+        labels_tree = describe_labels(self, labels_data=labels_data, as_subtree=True)
         if labels_tree:
-            if annotations_tree is None:
-                annotations_tree = tree.add(
-                    Text("Annotations", style="bold dark_orange")
-                )
-            annotations_tree.add(labels_tree)
+            tree.add(labels_tree)
 
     return tree
 

lamindb/core/_label_manager.py

@@ -5,12 +5,13 @@ from collections import defaultdict
 from typing import TYPE_CHECKING
 
 from django.db import connections
-from lamin_utils import colors, logger
+from lamin_utils import logger
 from lnschema_core.models import CanCurate, Feature
 from rich.table import Column, Table
 from rich.text import Text
+from rich.tree import Tree
 
-from lamindb._from_values import _print_values
+from lamindb._from_values import _format_values
 from lamindb._record import (
     REGISTRY_UNIQUE_FIELD,
     get_name_field,
@@ -32,7 +33,6 @@ from .schema import dict_related_model_to_related_name
 
 if TYPE_CHECKING:
     from lnschema_core.models import Artifact, Collection, Record
-    from rich.tree import Tree
 
     from lamindb._query_set import QuerySet
 
@@ -99,15 +99,10 @@ def describe_labels(
         return tree
 
     labels_table = Table(
-        Column(
-            Text.assemble(("Labels", "green_yellow")),
-            style="",
-            no_wrap=True,
-            width=NAME_WIDTH,
-        ),
+        Column("", style="", no_wrap=True, width=NAME_WIDTH),
         Column("", style="dim", no_wrap=True, width=TYPE_WIDTH),
         Column("", width=VALUES_WIDTH, no_wrap=True),
-        # show_header=True,
+        show_header=False,
         box=None,
         pad_edge=False,
     )
@@ -115,10 +110,12 @@ def describe_labels(
         if not labels or related_name == "feature_sets":
             continue
         if isinstance(labels, dict):  # postgres, labels are a dict[id, name]
-            print_values = _print_values(labels.values(), n=10)
+            print_values = _format_values(labels.values(), n=10, quotes=False)
         else:  # labels are a QuerySet
             field = get_name_field(labels)
-            print_values = _print_values(labels.values_list(field, flat=True), n=10)
+            print_values = _format_values(
+                labels.values_list(field, flat=True), n=10, quotes=False
+            )
         if print_values:
             related_model = get_related_model(self, related_name)
             type_str = related_model.__get_name_with_schema__()
@@ -126,12 +123,16 @@ def describe_labels(
                 f".{related_name}", Text(type_str, style="dim"), print_values
             )
 
+    labels_header = Text("Labels", style="bold green_yellow")
     if as_subtree:
         if labels_table.rows:
-            return labels_table
+            labels_tree = Tree(labels_header, guide_style="dim")
+            labels_tree.add(labels_table)
+            return labels_tree
     else:
         if labels_table.rows:
-            tree.add(labels_table)
+            labels_tree = tree.add(labels_header)
+            labels_tree.add(labels_table)
         return tree
 
 

lamindb/core/loaders.py

@@ -110,8 +110,23 @@ def load_json(path: UPathStr) -> dict:
     return data
 
 
+def load_yaml(path: UPathStr) -> dict | UPathStr:
+    """Load `.yaml` to `dict`."""
+    try:
+        import yaml  # type: ignore
+
+        with open(path) as f:
+            data = yaml.safe_load(f)
+        return data
+    except ImportError:
+        logger.warning(
+            "Please install PyYAML (`pip install PyYAML`) to load `.yaml` files."
+        )
+        return path
+
+
 def load_image(path: UPathStr) -> None | UPathStr:
-    """Display `.svg` in ipython, otherwise return path."""
+    """Display `.jpg`, `.gif` or `.png` in ipython, otherwise return path."""
     if is_run_from_ipython:
         from IPython.display import Image, display
 
@@ -147,7 +162,9 @@ FILE_LOADERS = {
     ".zarr": load_anndata_zarr,
     ".html": load_html,
     ".json": load_json,
+    ".yaml": load_yaml,
     ".h5mu": load_h5mu,
+    ".gif": load_image,
     ".jpg": load_image,
     ".png": load_image,
     ".svg": load_svg,

lamindb/core/storage/_tiledbsoma.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Literal
 
 from anndata import AnnData, read_h5ad
+from lamin_utils import logger
 from lamindb_setup import settings as setup_settings
 from lamindb_setup.core._settings_storage import get_storage_region
 from lamindb_setup.core.upath import LocalPathClasses, create_path
@@ -178,6 +179,7 @@ def save_tiledbsoma_experiment(
         assert len(adata_objects) == 1  # noqa: S101
         n_observations = adata_objects[0].n_obs
 
+    logger.important(f"Writing the tiledbsoma store to {storepath}")
     for adata_obj in adata_objects:
         soma_io.from_anndata(
             storepath,

{lamindb-0.77.2.dist-info → lamindb-0.77.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: lamindb
-Version: 0.77.2
+Version: 0.77.4
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.9,<3.13
@@ -10,12 +10,13 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: lnschema_core==0.77.1
-Requires-Dist: lamin_utils==0.13.9
+Requires-Dist: lamin_utils==0.13.10
 Requires-Dist: lamin_cli==0.22.0
-Requires-Dist: lamindb_setup==0.81.2
+Requires-Dist: lamindb_setup==0.81.5
 Requires-Dist: pyarrow
 Requires-Dist: typing_extensions!=4.6.0
 Requires-Dist: python-dateutil
+Requires-Dist: pandas>=2.0.0
 Requires-Dist: anndata>=0.8.0,<=0.11.1
 Requires-Dist: fsspec
 Requires-Dist: graphviz