lamindb 0.71.3__py3-none-any.whl → 0.72.1__py3-none-any.whl

lamindb/core/_data.py

@@ -18,10 +18,6 @@ from lnschema_core.models import (
     format_field_value,
 )
 
-from lamindb._feature_set import (
-    dict_related_model_to_related_name,
-    dict_schema_name_to_model_name,
-)
 from lamindb._parents import view_lineage
 from lamindb._query_set import QuerySet
 from lamindb.core._settings import settings
@@ -36,6 +32,10 @@ from ._feature_manager import (
 from ._label_manager import LabelManager, print_labels
 from ._run_context import run_context
 from .exceptions import ValidationError
+from .schema import (
+    dict_related_model_to_related_name,
+    dict_schema_name_to_model_name,
+)
 
 if TYPE_CHECKING:
     from lnschema_core.types import StrField
@@ -87,7 +87,7 @@ def save_feature_set_links(self: Artifact | Collection) -> None:
         for slot, feature_set in self._feature_sets.items():
             kwargs = {
                 host_id_field: self.id,
-                "feature_set_id": feature_set.id,
+                "featureset_id": feature_set.id,
                 "slot": slot,
             }
             links.append(Data.feature_sets.through(**kwargs))
@@ -175,16 +175,13 @@ def describe(self: Data):
 
 
 def validate_feature(feature: Feature, records: list[Registry]) -> None:
-    """Validate feature record, set feature.registries based on labels records."""
+    """Validate feature record, adjust feature.dtype based on labels records."""
     if not isinstance(feature, Feature):
         raise TypeError("feature has to be of type Feature")
     if feature._state.adding:
         registries = {record.__class__.__get_name_with_schema__() for record in records}
         registries_str = "|".join(registries)
-        msg = (
-            f"ln.Feature(name='{feature.name}', type='category',"
-            f" registries='{registries_str}').save()"
-        )
+        msg = f"ln.Feature(name='{feature.name}', type='cat[{registries_str}]').save()"
         raise ValidationError(f"Feature not validated. If it looks correct: {msg}")
 
 
@@ -197,9 +194,9 @@ def get_labels(
     """{}."""
     if not isinstance(feature, Feature):
         raise TypeError("feature has to be of type Feature")
-    if feature.registries is None:
+    if feature.dtype is None or not feature.dtype.startswith("cat["):
         raise ValueError("feature does not have linked labels")
-    registries_to_check = feature.registries.split("|")
+    registries_to_check = feature.dtype.replace("cat[", "").rstrip("]").split("|")
     if len(registries_to_check) > 1 and not mute:
         logger.warning("labels come from multiple registries!")
     # return an empty query set if self.id is still None
@@ -209,13 +206,13 @@ def get_labels(
     for registry in registries_to_check:
         # currently need to distinguish between ULabel and non-ULabel, because
         # we only have the feature information for Label
-        if registry == "core.ULabel":
+        if registry == "ULabel":
             links_to_labels = get_label_links(self, registry, feature)
             label_ids = [link.ulabel_id for link in links_to_labels]
             qs_by_registry[registry] = ULabel.objects.using(self._state.db).filter(
                 id__in=label_ids
             )
-        else:
+        elif registry in self.features.accessor_by_orm:
             qs_by_registry[registry] = getattr(
                 self, self.features.accessor_by_orm[registry]
             ).all()
@@ -227,7 +224,7 @@ def get_labels(
         for v in qs_by_registry.values():
             values += v.list(get_default_str_field(v))
         return values
-    if len(registries_to_check) == 1:
+    if len(registries_to_check) == 1 and registry in qs_by_registry:
         return qs_by_registry[registry]
     else:
         return qs_by_registry
@@ -261,9 +258,9 @@ def add_labels(
                 "Please pass a feature, e.g., via: label = ln.ULabel(name='my_label',"
                 " feature=ln.Feature(name='my_feature'))"
             )
-        if feature.registries is not None:
+        if feature.dtype.startswith("cat["):
             orm_dict = dict_schema_name_to_model_name(Artifact)
-            for reg in feature.registries.split("|"):
+            for reg in feature.dtype.replace("cat[", "").rstrip("]").split("|"):
                 orm = orm_dict.get(reg)
                 records_validated += orm.from_values(records, field=field)
 
@@ -304,6 +301,9 @@ def add_labels(
                 record
             )
         for registry_name, records in records_by_registry.items():
+            if registry_name not in self.features.accessor_by_orm:
+                logger.warning(f"skipping {registry_name}")
+                continue
             labels_accessor = getattr(
                 self, self.features.accessor_by_orm[registry_name]
             )
@@ -313,26 +313,29 @@ def add_labels(
                 labels_accessor.remove(*linked_labels)
             labels_accessor.add(*records, through_defaults={"feature_id": feature.id})
         feature_set_links = get_feature_set_links(self)
-        feature_set_ids = [link.feature_set_id for link in feature_set_links.all()]
+        feature_set_ids = [link.featureset_id for link in feature_set_links.all()]
         # get all linked features of type Feature
         feature_sets = FeatureSet.filter(id__in=feature_set_ids).all()
         linked_features_by_slot = {
-            feature_set_links.filter(feature_set_id=feature_set.id)
+            feature_set_links.filter(featureset_id=feature_set.id)
             .one()
             .slot: feature_set.features.all()
             for feature_set in feature_sets
-            if "core.Feature" == feature_set.registry
+            if "Feature" == feature_set.registry
         }
         for registry_name, _ in records_by_registry.items():
             msg = ""
-            if feature.registries is None or registry_name not in feature.registries:
+            if (
+                not feature.dtype.startswith("cat[")
+                or registry_name not in feature.dtype
+            ):
                 if len(msg) > 0:
                     msg += ", "
                 msg += f"linked feature '{feature.name}' to registry '{registry_name}'"
-                if feature.registries is None:
-                    feature.registries = registry_name
-                elif registry_name not in feature.registries:
-                    feature.registries += f"|{registry_name}"
+                if not feature.dtype.startswith("cat["):
+                    feature.dtype = f"cat[{registry_name}]"
+                elif registry_name not in feature.dtype:
+                    feature.dtype = feature.dtype.rstrip("]") + f"|{registry_name}]"
                 feature.save()
             if len(msg) > 0:
                 logger.save(msg)
@@ -357,11 +360,11 @@ def add_labels(
                     ).one()
                     old_feature_set_link.delete()
                     remaining_links = self.feature_sets.through.objects.filter(
-                        feature_set_id=feature_set.id
+                        featureset_id=feature_set.id
                     ).all()
                     if len(remaining_links) == 0:
                         old_feature_set = FeatureSet.filter(
-                            id=old_feature_set_link.feature_set_id
+                            id=old_feature_set_link.featureset_id
                         ).one()
                         logger.info(
                             "nothing links to it anymore, deleting feature set"

lamindb/core/_feature_manager.py

@@ -7,7 +7,15 @@ import anndata as ad
 from anndata import AnnData
 from lamin_utils import colors, logger
 from lamindb_setup.core.upath import create_path
-from lnschema_core.models import Artifact, Collection, Data, Feature, Registry
+from lnschema_core.models import (
+    Artifact,
+    Collection,
+    Data,
+    Feature,
+    FeatureValue,
+    Registry,
+    ULabel,
+)
 
 from lamindb._feature import convert_numpy_dtype_to_lamin_feature_type
 from lamindb._feature_set import FeatureSet
@@ -18,6 +26,7 @@ from lamindb._registry import (
     transfer_to_default_db,
 )
 from lamindb._save import save
+from lamindb.core.exceptions import ValidationError
 from lamindb.core.storage import LocalPathClasses
 
 from ._settings import settings
@@ -41,8 +50,8 @@ def get_accessor_by_orm(host: Artifact | Collection) -> dict:
         field.related_model.__get_name_with_schema__(): field.name
         for field in host._meta.related_objects
     }
-    dictionary["core.Feature"] = "features"
-    dictionary["core.ULabel"] = "ulabels"
+    dictionary["Feature"] = "features"
+    dictionary["ULabel"] = "ulabels"
     return dictionary
 
 
@@ -60,10 +69,9 @@ def get_feature_set_by_slot(host) -> dict:
     feature_set_links = (
         host.feature_sets.through.objects.using(host_db)
         .filter(**kwargs)
-        .select_related("feature_set")
+        .select_related("featureset")
     )
-
-    return {fsl.slot: fsl.feature_set for fsl in feature_set_links}
+    return {fsl.slot: fsl.featureset for fsl in feature_set_links}
 
 
 def get_label_links(
@@ -93,7 +101,7 @@ def print_features(self: Data) -> str:
 
     messages = []
     for slot, feature_set in get_feature_set_by_slot(self).items():
-        if feature_set.registry != "core.Feature":
+        if feature_set.registry != "Feature":
             features = feature_set.members
             # features.first() is a lot slower than features[0] here
             name_field = get_default_str_field(features[0])
@@ -110,17 +118,15 @@ def print_features(self: Data) -> str:
             messages.append(
                 f"  {colors.bold(slot)}: {format_repr(feature_set, exclude='hash')}\n"
             )
-            for name, row_type, registries in feature_set.features.values_list(
-                "name", "type", "registries"
-            ):
-                if row_type == "category" and registries is not None:
+            for name, dtype in feature_set.features.values_list("name", "dtype"):
+                if dtype.startswith("cat["):
                     labels = self.labels.get(features_lookup.get(name), mute=True)
                     indent = ""
                     if isinstance(labels, dict):
-                        messages.append(f"    🔗 {name} ({registries})\n")
+                        messages.append(f"    🔗 {name} ({dtype})\n")
                         indent = "    "
                     else:
-                        labels = {registries: labels}
+                        labels = {dtype: labels}
                     for registry, registry_labels in labels.items():
                         field = get_default_str_field(registry_labels)
                         values_list = registry_labels.values_list(field, flat=True)
@@ -131,7 +137,7 @@ def print_features(self: Data) -> str:
                         )
                         messages.append(msg_objects)
                 else:
-                    messages.append(f"    {name} ({row_type})\n")
+                    messages.append(f"    {name} ({dtype})\n")
     if messages:
         messages.insert(0, f"{colors.green('Features')}:\n")
     return "".join(messages)
@@ -171,6 +177,7 @@ def parse_feature_sets_from_anndata(
             type=type,
             mute=mute,
             organism=organism,
+            raise_validation_error=False,
         )
         if feature_set_var is not None:
             feature_sets["var"] = feature_set_var
@@ -243,14 +250,79 @@ class FeatureManager:
             self._accessor_by_orm = get_accessor_by_orm(self._host)
         return self._accessor_by_orm
 
-    def add(self, features: Iterable[Registry], slot: str | None = None):
-        """Add features stratified by slot."""
-        if (hasattr(self._host, "accessor") and self._host.accessor == "DataFrame") or (
-            hasattr(self._host, "artifact")
-            and self._host.artifact.accessor == "DataFrame"
-        ):
-            slot = "columns" if slot is None else slot
-        self.add_feature_set(feature_set=FeatureSet(features=features), slot=slot)
+    def add(
+        self,
+        features_values: dict[str, str | int | float | bool],
+        slot: str | None = None,
+        feature_field: FieldAttr = Feature.name,
+    ):
+        """Add features stratified by slot.
+
+        Args:
+            features_values: A dictionary of features & values. You can also
+              pass `{feature_identifier: None}` to skip annotation by values.
+            slot: The access slot of the feature sets in the artifact. For
+              instance, `.columns` for `DataFrame` or `.var` or `.obs` for
+              `AnnData`.
+            feature_field: The field of a reference registry to map values.
+        """
+        if slot is None:
+            slot = "external"
+        keys = features_values.keys()
+        features_values.values()
+        # what if the feature is already part of a linked feature set?
+        # what if artifact annotation by features through link tables and through feature sets
+        # differs?
+        feature_set = FeatureSet.from_values(keys, field=feature_field)
+        self._host.features.add_feature_set(feature_set, slot)
+        # now figure out which of the values go where
+        features_labels = []
+        feature_values = []
+        for key, value in features_values.items():
+            # TODO: use proper field in .get() below
+            feature = feature_set.features.get(name=key)
+            if feature.dtype == "number":
+                if not (isinstance(value, int) or isinstance(value, float)):
+                    raise TypeError(
+                        f"Value for feature '{key}' with type {feature.dtype} must be a number"
+                    )
+            elif feature.dtype == "cat":
+                if not (isinstance(value, str) or isinstance(value, Registry)):
+                    raise TypeError(
+                        f"Value for feature '{key}' with type '{feature.dtype}' must be a string or record."
+                    )
+            elif feature.dtype == "bool":
+                assert isinstance(value, bool)
+            if feature.dtype == "cat":
+                if isinstance(value, Registry):
+                    assert not value._state.adding
+                    label_record = value
+                    assert isinstance(label_record, ULabel)
+                else:
+                    label_record = ULabel.filter(name=value).one_or_none()
+                    if label_record is None:
+                        raise ValidationError(f"Label '{value}' not found in ln.ULabel")
+                features_labels.append((feature, label_record))
+            else:
+                feature_values.append(FeatureValue(feature=feature, value=value))
+        # bulk add all links to ArtifactULabel
+        if features_labels:
+            LinkORM = self._host.ulabels.through
+            links = [
+                LinkORM(
+                    artifact_id=self._host.id, feature_id=feature.id, ulabel_id=label.id
+                )
+                for (feature, label) in features_labels
+            ]
+            LinkORM.objects.bulk_create(links, ignore_conflicts=True)
+        if feature_values:
+            save(feature_values)
+            LinkORM = self._host.feature_values.through
+            links = [
+                LinkORM(artifact_id=self._host.id, featurevalue_id=feature_value.id)
+                for feature_value in feature_values
+            ]
+            LinkORM.objects.bulk_create(links)
 
     def add_from_df(self, field: FieldAttr = Feature.name, organism: str | None = None):
         """Add features from DataFrame."""
@@ -355,7 +427,7 @@ class FeatureManager:
         host_id_field = get_host_id_field(self._host)
         kwargs = {
             host_id_field: self._host.id,
-            "feature_set": feature_set,
+            "featureset": feature_set,
             "slot": slot,
         }
         link_record = (
@@ -366,7 +438,7 @@ class FeatureManager:
         if link_record is None:
             self._host.feature_sets.through(**kwargs).save(using=host_db)
             if slot in self.feature_set_by_slot:
-                logger.warning(f"replaced existing {slot} featureset")
+                logger.debug(f"replaced existing {slot} feature set")
             # this _feature_set_by_slot here is private
             self._feature_set_by_slot[slot] = feature_set  # type: ignore
 

lamindb/core/_label_manager.py

@@ -4,9 +4,8 @@ from typing import TYPE_CHECKING, Dict
 
 import numpy as np
 from lamin_utils import colors, logger
-from lnschema_core.models import Artifact, Collection, Data, Feature, Registry
+from lnschema_core.models import Artifact, Collection, Data, Feature, LinkORM, Registry
 
-from lamindb._feature_set import dict_related_model_to_related_name
 from lamindb._from_values import _print_values
 from lamindb._registry import (
     REGISTRY_UNIQUE_FIELD,
@@ -17,14 +16,17 @@ from lamindb._registry import (
 from lamindb._save import save
 
 from ._settings import settings
+from .schema import dict_related_model_to_related_name
 
 if TYPE_CHECKING:
     from lamindb._query_set import QuerySet
 
 
 def get_labels_as_dict(self: Data):
-    labels = {}
-    for related_model, related_name in dict_related_model_to_related_name(
+    labels = {}  # type: ignore
+    if self.id is None:
+        return labels
+    for related_model_name, related_name in dict_related_model_to_related_name(
         self.__class__
     ).items():
         if related_name in {
@@ -37,12 +39,13 @@ def get_labels_as_dict(self: Data):
             "environment_of",
         }:
             continue
-        if self.id is not None:
-            labels[related_name] = (related_model, self.__getattribute__(related_name))
+        labels[related_name] = (related_model_name, self.__getattribute__(related_name))
     return labels
 
 
-def print_labels(self: Data, field: str = "name"):
+def print_labels(
+    self: Data, field: str = "name", ignore_labels_with_feature: bool = True
+):
     labels_msg = ""
     for related_name, (related_model, labels) in get_labels_as_dict(self).items():
         try:
@@ -210,11 +213,11 @@ class LabelManager:
         }
         for _, feature_set in data.features.feature_set_by_slot.items():
             # add labels stratified by feature
-            if feature_set.registry == "core.Feature":
-                # df_slot is the Feature table with type and registries
+            if feature_set.registry == "Feature":
+                # df_slot is the Feature table with type
                 df_slot = feature_set.features.df()
                 for _, row in df_slot.iterrows():
-                    if row["type"] == "category" and row["registries"] is not None:
+                    if row["dtype"].startswith("cat["):
                         logger.info(f"transferring {row['name']}")
                         # labels records from data db
                         labels = data.labels.get(

lamindb/core/_run_context.py

@@ -10,9 +10,11 @@ from typing import TYPE_CHECKING
 from lamin_utils import logger
 from lamindb_setup.core.hashing import hash_file
 from lnschema_core import Run, Transform, ids
+from lnschema_core.models import Param, ParamValue, RunParamValue
 from lnschema_core.types import TransformType
 from lnschema_core.users import current_user_id
 
+from lamindb._save import save
 from lamindb.core._transform_settings import transform as transform_settings
 
 from ._settings import settings
@@ -187,6 +189,26 @@ def pretty_pypackages(dependencies: dict) -> str:
     return " ".join(deps_list)
 
 
+def parse_and_link_params(run: Run, params: dict) -> None:
+    param_values = []
+    for key, value in params.items():
+        param = Param.filter(name=key).one_or_none()
+        if param is None:
+            dtype = type(value).__name__
+            logger.warning(
+                f"param '{key}' does not yet exist, creating it with dtype '{dtype}'"
+            )
+            param = Param(name=key, dtype=dtype).save()
+        param_value, _ = ParamValue.objects.get_or_create(param=param, value=value)
+        param_values.append(param_value)
+    if param_values:
+        links = [
+            RunParamValue(run_id=run.id, paramvalue_id=param_value.id)
+            for param_value in param_values
+        ]
+        RunParamValue.objects.bulk_create(links)
+
+
 class run_context:
     """Global run context."""
 
@@ -312,7 +334,6 @@ class run_context:
             )
             if run is not None:  # loaded latest run
                 run.started_at = datetime.now(timezone.utc)  # update run time
-                run.json = params  # update run params
                 logger.important(f"loaded: {run}")
 
         if run is None:  # create new run
@@ -326,6 +347,8 @@ class run_context:
         run.is_consecutive = True if is_run_from_ipython else None
         # need to save in all cases
         run.save()
+        if params is not None:
+            parse_and_link_params(run, params)
         cls.run = run
 
         from ._track_environment import track_environment

lamindb/core/datasets/_core.py

@@ -45,10 +45,8 @@ def file_fcs_alpert19(populate_registries: bool = False) -> Path:  # pragma: no
                 bt.CellMarker.public().inspect(std, "name").validated, "name"
             )
         )
-        ln.Feature(
-            name="assay", type="category", registries=[bt.ExperimentalFactor]
-        ).save()
-        ln.Feature(name="organism", type="category", registries=[bt.Organism]).save()
+        ln.Feature(name="assay", dtype=[bt.ExperimentalFactor]).save()
+        ln.Feature(name="organism", dtype=[bt.Organism]).save()
         ln.settings.verbosity = verbosity
     return Path(filepath)
 
@@ -83,10 +81,8 @@ def file_tsv_rnaseq_nfcore_salmon_merged_gene_counts(
 
         verbosity = ln.settings.verbosity
         ln.settings.verbosity = "error"
-        ln.Feature(
-            name="assay", type="category", registries=[bt.ExperimentalFactor]
-        ).save()
-        ln.Feature(name="organism", type="category", registries=[bt.Organism]).save()
+        ln.Feature(name="assay", dtype=[bt.ExperimentalFactor]).save()
+        ln.Feature(name="organism", dtype=[bt.Organism]).save()
         bt.ExperimentalFactor.from_public(ontology_id="EFO:0008896").save()
         ln.settings.verbosity = verbosity
 
@@ -200,9 +196,7 @@ def anndata_mouse_sc_lymph_node(
         # cell types
         ln.save(bt.CellType.from_values(["CL:0000115", "CL:0000738"], "ontology_id"))
         # assays
-        ln.Feature(
-            name="assay", type="category", registries=[bt.ExperimentalFactor]
-        ).save()
+        ln.Feature(name="assay", dtype=[bt.ExperimentalFactor]).save()
         bt.ExperimentalFactor.from_public(ontology_id="EFO:0008913").save()
         # genes
         validated = bt.Gene.public(organism="mouse").validate(
@@ -329,13 +323,11 @@ def anndata_human_immune_cells(
         ln.save(bt.CellType.from_values(adata.obs.cell_type, field="name"))
         ln.save(bt.ExperimentalFactor.from_values(adata.obs.assay, field="name"))
         ln.save(bt.Tissue.from_values(adata.obs.tissue, field="name"))
-        ln.Feature(name="cell_type", type="category", registries=[bt.CellType]).save()
-        ln.Feature(
-            name="assay", type="category", registries=[bt.ExperimentalFactor]
-        ).save()
-        ln.Feature(name="tissue", type="category", registries=[bt.Tissue]).save()
-        ln.Feature(name="organism", type="category", registries=[bt.Organism]).save()
-        ln.Feature(name="donor", type="category", registries=[ln.ULabel]).save()
+        ln.Feature(name="cell_type", dtype=[bt.CellType]).save()
+        ln.Feature(name="assay", dtype=[bt.ExperimentalFactor]).save()
+        ln.Feature(name="tissue", dtype=[bt.Tissue]).save()
+        ln.Feature(name="organism", dtype=[bt.Organism]).save()
+        ln.Feature(name="donor", dtype=[ln.ULabel]).save()
         bt.ExperimentalFactor.from_public(ontology_id="EFO:0008913").save()
         ln.save([ln.ULabel(name=name) for name in adata.obs.donor.unique()])
         ln.settings.verbosity = verbosity

lamindb/core/schema.py

@@ -0,0 +1,53 @@
+from typing import Type
+
+from lnschema_core.models import Feature, FeatureSet, LinkORM, Registry
+
+
+def dict_schema_name_to_model_name(orm: Type[Registry]) -> dict[str, Registry]:
+    d: dict = {
+        i.related_model.__get_name_with_schema__(): i.related_model
+        for i in orm._meta.related_objects
+        if i.related_name is not None
+    }
+    d.update(
+        {
+            i.related_model.__get_name_with_schema__(): i.related_model
+            for i in orm._meta.many_to_many
+            if i.name is not None
+        }
+    )
+    return d
+
+
+def dict_related_model_to_related_name(orm: Type[Registry]) -> dict[str, str]:
+    d: dict = {
+        i.related_model.__get_name_with_schema__(): i.related_name
+        for i in orm._meta.related_objects
+        if (i.name is not None and not issubclass(i.related_model, LinkORM))
+    }
+    d.update(
+        {
+            i.related_model.__get_name_with_schema__(): i.name
+            for i in orm._meta.many_to_many
+            if (i.name is not None and not issubclass(i.related_model, LinkORM))
+        }
+    )
+
+    return d
+
+
+def get_related_name(features_type: type[Registry]) -> str:
+    candidates = [
+        field.related_name
+        for field in FeatureSet._meta.related_objects
+        if field.related_model == features_type
+    ]
+    if not candidates:
+        raise ValueError(
+            f"Can't create feature sets from {features_type.__name__} because it's not"
+            " related to it!\nYou need to create a link model between FeatureSet and"
+            " your Registry in your custom schema.\nTo do so, add a"
+            " line:\nfeature_sets = models.ManyToMany(FeatureSet,"
+            " related_name='mythings')\n"
+        )
+    return candidates[0]

{lamindb-0.71.3.dist-info → lamindb-0.72.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb
-Version: 0.71.3
+Version: 0.72.1
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.8
@@ -9,8 +9,8 @@ Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: lnschema_core==0.66.5
-Requires-Dist: lamindb_setup==0.71.4
+Requires-Dist: lnschema_core==0.67.1
+Requires-Dist: lamindb_setup==0.72.2
 Requires-Dist: lamin_utils==0.13.2
 Requires-Dist: lamin_cli==0.13.2
 Requires-Dist: rapidfuzz
@@ -25,7 +25,7 @@ Requires-Dist: graphviz
 Requires-Dist: psycopg2-binary
 Requires-Dist: psutil
 Requires-Dist: lamindb_setup[aws] ; extra == "aws"
-Requires-Dist: bionty==0.42.11 ; extra == "bionty"
+Requires-Dist: bionty==0.43.1 ; extra == "bionty"
 Requires-Dist: pandas<2 ; extra == "dev"
 Requires-Dist: pre-commit ; extra == "dev"
 Requires-Dist: nox ; extra == "dev"