lamindb 0.76.11__py3-none-any.whl → 0.76.13__py3-none-any.whl

lamindb/__init__.py

@@ -43,7 +43,7 @@ Modules and settings.
 """
 
 # denote a release candidate for 0.1.0 with 0.1rc1, 0.1a1, 0.1b1, etc.
-__version__ = "0.76.11"
+__version__ = "0.76.13"
 
 import os as _os
 

lamindb/_artifact.py

@@ -10,7 +10,7 @@ import fsspec
 import lamindb_setup as ln_setup
 import pandas as pd
 from anndata import AnnData
-from django.db.models import Q, QuerySet
+from django.db.models import Q
 from lamin_utils import colors, logger
 from lamindb_setup import settings as setup_settings
 from lamindb_setup._init_instance import register_storage_in_instance
@@ -180,7 +180,7 @@ def process_data(
                 f" be '{suffix}'."
             )
         cache_name = f"{provisional_uid}{suffix}"
-        path = settings.storage.cache_dir / cache_name
+        path = settings.cache_dir / cache_name
         # Alex: I don't understand the line below
         if path.suffixes == []:
             path = path.with_suffix(suffix)
@@ -331,9 +331,10 @@ def get_artifact_kwargs_from_data(
         artifact = stat_or_artifact
         # update the run of the existing artifact
         if run is not None:
-            # save the information that this artifact was previously
-            # produced by another run
-            if artifact.run is not None:
+            # save the information that this artifact was previously produced by
+            # another run
+            # note: same logic exists for _output_collections_with_later_updates
+            if artifact.run is not None and artifact.run != run:
                 artifact.run._output_artifacts_with_later_updates.add(artifact)
             # update the run of the artifact with the latest run
             stat_or_artifact.run = run
@@ -344,7 +345,7 @@ def get_artifact_kwargs_from_data(
 
     if revises is not None:  # update provisional_uid
         provisional_uid, revises = create_uid(revises=revises, version=version)
-        if settings.storage.cache_dir in path.parents:
+        if settings.cache_dir in path.parents:
             path = path.rename(path.with_name(f"{provisional_uid}{suffix}"))
 
     check_path_in_storage = False
@@ -749,10 +750,6 @@ def from_dir(
     run: Run | None = None,
 ) -> list[Artifact]:
     """{}"""  # noqa: D415
-    logger.warning(
-        "this creates one artifact per file in the directory - consider"
-        " ln.Artifact(dir_path) to get one artifact for the entire directory"
-    )
     folderpath: UPath = create_path(path)  # returns Path for local
     default_storage = settings.storage.record
     using_key = settings._using_key
@@ -1125,7 +1122,7 @@ def save(self, upload: bool | None = None, **kwargs) -> Artifact:
         raise RuntimeError(exception)
     if local_path is not None and not state_was_adding:
         # only move the local artifact to cache if it was not newly created
-        local_path_cache = ln_setup.settings.storage.cache_dir / local_path.name
+        local_path_cache = ln_setup.settings.cache_dir / local_path.name
         # don't use Path.rename here because of cross-device link error
         # https://laminlabs.slack.com/archives/C04A0RMA0SC/p1710259102686969
         shutil.move(

lamindb/_collection.py

@@ -145,15 +145,16 @@ def __init__(
         logger.warning(
             f"returning existing collection with same hash: {existing_collection}"
         )
-        # update the run of the existing artifact
+        # update the run of the existing collection
         if run is not None:
-            # save the information that this artifact was previously
-            # produced by another run
-            if existing_collection.run is not None:
+            # save the information that this collection was previously produced
+            # by another run
+            # note: same logic exists for _output_artifacts_with_later_updates
+            if existing_collection.run is not None and existing_collection.run != run:
                 existing_collection.run._output_collections_with_later_updates.add(
                     existing_collection
                 )
-            # update the run of the artifact with the latest run
+            # update the run of the collection with the latest run
             existing_collection.run = run
             existing_collection.transform = run.transform
         init_self_from_db(collection, existing_collection)

lamindb/_feature_set.py

@@ -216,7 +216,9 @@ def members(self) -> QuerySet:
 
 
 def _get_related_name(self: FeatureSet) -> str:
-    feature_sets_related_models = dict_related_model_to_related_name(self)
+    feature_sets_related_models = dict_related_model_to_related_name(
+        self, instance=self._state.db
+    )
     related_name = feature_sets_related_models.get(self.registry)
     return related_name
 

lamindb/_filter.py

@@ -2,8 +2,6 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from lnschema_core import Artifact, Collection
-
 from ._query_set import QuerySet, process_expressions
 
 if TYPE_CHECKING:

lamindb/_finish.py

@@ -130,12 +130,12 @@ def save_context_core(
                 if response != "y":
                     return "aborted-non-consecutive"
         # write the report
-        report_path = ln_setup.settings.storage.cache_dir / filepath.name.replace(
+        report_path = ln_setup.settings.cache_dir / filepath.name.replace(
             ".ipynb", ".html"
         )
         notebook_to_report(filepath, report_path)
         # write the source code
-        source_code_path = ln_setup.settings.storage.cache_dir / filepath.name.replace(
+        source_code_path = ln_setup.settings.cache_dir / filepath.name.replace(
             ".ipynb", ".py"
         )
         notebook_to_script(transform, filepath, source_code_path)
@@ -171,7 +171,7 @@ def save_context_core(
         transform.hash = hash
 
     # track environment
-    env_path = ln_setup.settings.storage.cache_dir / f"run_env_pip_{run.uid}.txt"
+    env_path = ln_setup.settings.cache_dir / f"run_env_pip_{run.uid}.txt"
     if env_path.exists():
         overwrite_env = True
         if run.environment_id is not None and from_cli:

lamindb/_parents.py

@@ -310,7 +310,12 @@ def _record_label(record: Record, field: str | None = None):
             rf' FACE="Monospace">uid={record.uid}<BR/>version={record.version}</FONT>>'
         )
     elif isinstance(record, Run):
-        name = f'{record.transform.name.replace("&", "&amp;")}'
+        if record.transform.name:
+            name = f'{record.transform.name.replace("&", "&amp;")}'
+        elif record.transform.key:
+            name = f'{record.transform.key.replace("&", "&amp;")}'
+        else:
+            name = f"{record.transform.uid}"
         user_display = (
             record.created_by.handle
             if record.created_by.name is None
@@ -365,7 +370,6 @@ def _get_all_parent_runs(data: Artifact | Collection) -> list:
                 inputs_run += (
                     r.input_collections.all().filter(visibility__in=[0, 1]).list()
                 )
-            run_inputs_outputs += [(inputs_run, r)]
             outputs_run = (
                 r.__getattribute__(f"output_{name}s")
                 .all()
@@ -376,7 +380,18 @@ def _get_all_parent_runs(data: Artifact | Collection) -> list:
                 outputs_run += (
                     r.output_collections.all().filter(visibility__in=[0, 1]).list()
                 )
-            run_inputs_outputs += [(r, outputs_run)]
+            # if inputs are outputs artifacts are the same, will result infinite loop
+            # so only show as outputs
+            overlap = set(inputs_run).intersection(outputs_run)
+            if overlap:
+                logger.warning(
+                    f"The following artifacts are both inputs and outputs of Run(uid={r.uid}): {overlap}\n   → Only showing as outputs."
+                )
+                inputs_run = list(set(inputs_run) - overlap)
+            if len(inputs_run) > 0:
+                run_inputs_outputs += [(inputs_run, r)]
+            if len(outputs_run) > 0:
+                run_inputs_outputs += [(r, outputs_run)]
             inputs += inputs_run
         runs = [f.run for f in inputs if f.run is not None]
     return run_inputs_outputs

lamindb/_query_manager.py

@@ -98,26 +98,11 @@ class QueryManager(models.Manager):
 
         return _lookup(cls=self.all(), field=field, **kwargs)
 
-    def __getitem__(self, item: str):
-        try:
-            source_field_name = self.source_field_name
-            target_field_name = self.target_field_name
-
-            if (
-                source_field_name in {"artifact", "collection"}
-                and target_field_name == "feature_set"
-            ):
-                return get_feature_set_by_slot_(host=self.instance).get(item)
-
-        except Exception:  # pragma: no cover
-            return
-
 
 models.Manager.list = QueryManager.list
 models.Manager.df = QueryManager.df
 models.Manager.search = QueryManager.search
 models.Manager.lookup = QueryManager.lookup
-models.Manager.__getitem__ = QueryManager.__getitem__
 models.Manager._track_run_input_manager = QueryManager._track_run_input_manager
 # the two lines below would be easy if we could actually inherit; like this,
 # they're suboptimal

lamindb/_query_set.py

@@ -115,7 +115,7 @@ def get(
     else:
         assert idlike is None  # noqa: S101
         expressions = process_expressions(registry, expressions)
-        return registry.objects.get(**expressions)
+        return registry.objects.using(qs.db).get(**expressions)
 
 
 class RecordsList(UserList):
@@ -139,7 +139,7 @@ class QuerySet(models.QuerySet):
 
     See Also:
 
-        `django QuerySet <https://docs.djangoproject.com/en/4.2/ref/models/querysets/>`__ # noqa
+        `django QuerySet <https://docs.djangoproject.com/en/4.2/ref/models/querysets/>`__
 
     Examples:
 
@@ -154,7 +154,7 @@ class QuerySet(models.QuerySet):
     ) -> pd.DataFrame:
         """{}"""  # noqa: D415
         # re-order the columns
-        exclude_field_names = ["created_at"]
+        exclude_field_names = ["updated_at"]
         field_names = [
             field.name
             for field in self.model._meta.fields

lamindb/_record.py

@@ -15,7 +15,7 @@ from lamindb_setup._connect_instance import (
     update_db_using_local,
 )
 from lamindb_setup.core._docs import doc_args
-from lamindb_setup.core._hub_core import connect_instance
+from lamindb_setup.core._hub_core import connect_instance_hub
 from lamindb_setup.core._settings_store import instance_settings_file
 from lnschema_core.models import IsVersioned, Record, Run, Transform
 
@@ -376,15 +376,15 @@ def using(
     instance: str | None,
 ) -> QuerySet:
     """{}"""  # noqa: D415
+    from ._query_set import QuerySet
+
     if instance is None:
         return QuerySet(model=cls, using=None)
     owner, name = get_owner_name_from_identifier(instance)
     settings_file = instance_settings_file(name, owner)
-    cache_filepath = (
-        ln_setup.settings.storage.cache_dir / f"instance--{owner}--{name}--uid.txt"
-    )
+    cache_filepath = ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
     if not settings_file.exists():
-        result = connect_instance(owner=owner, name=name)
+        result = connect_instance_hub(owner=owner, name=name)
         if isinstance(result, str):
             raise RuntimeError(
                 f"Failed to load instance {instance}, please check your permissions!"
@@ -397,15 +397,15 @@ def using(
         if not source_schema.issubset(target_schema):
             missing_members = source_schema - target_schema
             logger.warning(
-                f"source schema has additional modules: {missing_members}\nconsider mounting these schema modules to not encounter errors"
+                f"source schema has additional modules: {missing_members}\nconsider mounting these schema modules to transfer all metadata"
             )
-        cache_filepath.write_text(iresult["lnid"])  # type: ignore
+        cache_filepath.write_text(f"{iresult['lnid']}\n{iresult['schema_str']}")  # type: ignore
         settings_file = instance_settings_file(name, owner)
         db = update_db_using_local(iresult, settings_file)
     else:
         isettings = load_instance_settings(settings_file)
         db = isettings.db
-        cache_filepath.write_text(isettings.uid)
+        cache_filepath.write_text(f"{isettings.uid}\n{','.join(isettings.schema)}")  # type: ignore
     add_db_connection(db, instance)
     return QuerySet(model=cls, using=instance)
 
@@ -469,12 +469,10 @@ def get_transfer_run(record) -> Run:
 
     slug = record._state.db
     owner, name = get_owner_name_from_identifier(slug)
-    cache_filepath = (
-        ln_setup.settings.storage.cache_dir / f"instance--{owner}--{name}--uid.txt"
-    )
+    cache_filepath = ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
     if not cache_filepath.exists():
         raise SystemExit("Need to call .using() before")
-    instance_uid = cache_filepath.read_text()
+    instance_uid = cache_filepath.read_text().split("\n")[0]
     key = f"transfers/{instance_uid}"
     uid = instance_uid + "0000"
     transform = Transform.filter(uid=uid).one_or_none()

lamindb/_save.py

@@ -168,7 +168,7 @@ def copy_or_move_to_cache(
 
     local_path = local_path.resolve()
     is_dir = local_path.is_dir()
-    cache_dir = settings._storage_settings.cache_dir
+    cache_dir = settings.cache_dir
 
     # just delete from the cache dir if storage_path is local
     if cache_path is None:

lamindb/core/_context.py

@@ -438,7 +438,7 @@ class Context:
             )
             return (
                 f'Filename "{key}" clashes with the existing key "{transform.key}" for uid "{transform.uid[:-4]}...."\n\nEither init a new transform with a new uid:\n\n'
-                f'ln.track("{ids.base62_12()}0000)"\n\n{update_key_note}'
+                f'ln.track("{ids.base62_12()}0000")\n\n{update_key_note}'
             )
 
         # make a new transform record
@@ -562,26 +562,32 @@ class Context:
 
             return "CMD + s" if platform.system() == "Darwin" else "CTRL + s"
 
-        if context.run is None:
+        if self.run is None:
             raise TrackNotCalled("Please run `ln.track()` before `ln.finish()`")
-        if context._path is None:
-            if context.run.transform.type in {"script", "notebook"}:
+        if self._path is None:
+            if self.run.transform.type in {"script", "notebook"}:
                 raise ValueError(
-                    f"Transform type is not allowed to be 'script' or 'notebook' but is {context.run.transform.type}."
+                    "Transform type is not allowed to be 'script' or 'notebook' because `context._path` is `None`."
                 )
-            context.run.finished_at = datetime.now(timezone.utc)
-            context.run.save()
+            self.run.finished_at = datetime.now(timezone.utc)
+            self.run.save()
             # nothing else to do
             return None
         if is_run_from_ipython:  # notebooks
-            if get_seconds_since_modified(context._path) > 2 and not ln_setup._TESTING:
+            import nbproject
+
+            # it might be that the user modifies the title just before ln.finish()
+            if (nbproject_title := nbproject.meta.live.title) != self.transform.name:
+                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()}`) right before calling `ln.finish()`"
                 )
         save_context_core(
-            run=context.run,
-            transform=context.run.transform,
-            filepath=context._path,
+            run=self.run,
+            transform=self.run.transform,
+            filepath=self._path,
             finished_at=True,
             ignore_non_consecutive=ignore_non_consecutive,
         )

lamindb/core/_django.py

@@ -6,7 +6,7 @@ from django.db.models.fields.reverse_related import ManyToManyRel, ManyToOneRel
 from django.db.models.functions import JSONObject
 from lnschema_core.models import Artifact, FeatureSet, Record
 
-from .schema import dict_related_model_to_related_name
+from .schema import dict_related_model_to_related_name, get_schemas_modules
 
 
 def get_related_model(model, field_name):
@@ -35,22 +35,36 @@ def get_artifact_with_related(
     """Fetch an artifact with its related data."""
     from lamindb._can_validate import get_name_field
 
+    from ._label_manager import LABELS_EXCLUDE_SET
+
     model = artifact.__class__
-    foreign_key_fields = [f.name for f in model._meta.fields if f.is_relation]
+    schema_modules = get_schemas_modules(artifact._state.db)
+
+    foreign_key_fields = [
+        f.name
+        for f in model._meta.fields
+        if f.is_relation and f.related_model.__get_schema_name__() in schema_modules
+    ]
 
     m2m_relations = (
         []
         if not include_m2m
         else [
             v
-            for v in dict_related_model_to_related_name(model).values()
-            if not v.startswith("_")
+            for v in dict_related_model_to_related_name(
+                model, instance=artifact._state.db
+            ).values()
+            if not v.startswith("_") and v not in LABELS_EXCLUDE_SET
         ]
     )
     link_tables = (
         []
         if not include_feature_link
-        else list(dict_related_model_to_related_name(model, links=True).values())
+        else list(
+            dict_related_model_to_related_name(
+                model, links=True, instance=artifact._state.db
+            ).values()
+        )
     )
 
     # Clear previous queries

lamindb/core/_feature_manager.py

@@ -40,7 +40,7 @@ from lamindb._record import (
     transfer_to_default_db,
 )
 from lamindb._save import save
-from lamindb.core.exceptions import ValidationError
+from lamindb.core.exceptions import DoesNotExist, ValidationError
 from lamindb.core.storage import LocalPathClasses
 
 from ._django import get_artifact_with_related
@@ -216,9 +216,11 @@ def _print_categoricals(
     if not print_params:
         labels_msg = ""
         labels_by_feature = defaultdict(list)
-        for _, (_, links) in get_labels_as_dict(self, links=True).items():
+        for _, (_, links) in get_labels_as_dict(
+            self, links=True, instance=self._state.db
+        ).items():
             for link in links:
-                if link.feature_id is not None:
+                if hasattr(link, "feature_id") and link.feature_id is not None:
                     link_attr = get_link_attr(link, self)
                     labels_by_feature[link.feature_id].append(
                         getattr(link, link_attr).name
@@ -509,18 +511,49 @@ def filter_base(cls, **expression):
             expression = {feature_param: feature, f"value{comparator}": value}
             feature_value = value_model.filter(**expression)
             new_expression[f"_{feature_param}_values__in"] = feature_value
-        else:
+        elif isinstance(value, (str, Record)):
+            # because SQL is sensitive to whether querying with __in or not
+            # and might return multiple equivalent records for the latter
+            # we distinguish cases in which we have multiple label matches vs. one
+            label = None
+            labels = None
             if isinstance(value, str):
+                # we need the comparator here because users might query like so
+                # ln.Artifact.features.filter(experiment__contains="Experi")
                 expression = {f"name{comparator}": value}
-                label = ULabel.get(**expression)
-                new_expression["ulabels"] = label
+                labels = ULabel.filter(**expression).all()
+                if len(labels) == 0:
+                    raise DoesNotExist(
+                        f"Did not find a ULabel matching `name{comparator}={value}`"
+                    )
+                elif len(labels) == 1:
+                    label = labels[0]
+            elif isinstance(value, Record):
+                label = value
+            label_registry = (
+                label.__class__ if label is not None else labels[0].__class__
+            )
+            accessor_name = (
+                label_registry.artifacts.through.artifact.field._related_name
+            )
+            new_expression[f"{accessor_name}__feature"] = feature
+            if label is not None:
+                # simplified query if we have exactly one label
+                new_expression[
+                    f"{accessor_name}__{label_registry.__name__.lower()}"
+                ] = label
             else:
-                raise NotImplementedError
+                new_expression[
+                    f"{accessor_name}__{label_registry.__name__.lower()}__in"
+                ] = labels
+        else:
+            # if passing a list of records, we want to
+            # find artifacts that are annotated by all of them at the same
+            # time; hence, we don't want the __in construct that we use to match strings
+            # https://laminlabs.slack.com/archives/C04FPE8V01W/p1688328084810609
+            raise NotImplementedError
     if cls == FeatureManager or cls == ParamManagerArtifact:
         return Artifact.filter(**new_expression)
-    # might renable something similar in the future
-    # elif cls == FeatureManagerCollection:
-    #     return Collection.filter(**new_expression)
     elif cls == ParamManagerRun:
         return Run.filter(**new_expression)
 

lamindb/core/_label_manager.py

@@ -26,32 +26,19 @@ if TYPE_CHECKING:
 
     from lamindb._query_set import QuerySet
 
+LABELS_EXCLUDE_SET = {"feature_sets"}
 
-def get_labels_as_dict(self: Artifact | Collection, links: bool = False):
-    exclude_set = {
-        "feature_sets",
-        "artifacts",
-        "input_of_runs",
-        "collections",
-        "_source_code_artifact_of",
-        "_report_of",
-        "_environment_of",
-        "links_collection",
-        "links_artifact",
-        "links_feature_set",
-        "previous_runs",
-        "_feature_values",
-        "_action_targets",
-        "_lnschema_core_collection__actions_+",  # something seems off with this one
-        "_actions",
-    }
+
+def get_labels_as_dict(
+    self: Artifact | Collection, links: bool = False, instance: str | None = None
+) -> dict:
     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__, links=links
+        self.__class__, links=links, instance=instance
     ).items():
-        if related_name not in exclude_set:
+        if related_name not in LABELS_EXCLUDE_SET and not related_name.startswith("_"):
             labels[related_name] = (
                 related_model_name,
                 getattr(self, related_name).all(),
@@ -86,18 +73,15 @@ def print_labels(
         labels_msg = _print_labels_postgres(self, m2m_data, print_types)
     else:
         labels_msg = ""
-        for related_name, (related_model, labels) in get_labels_as_dict(self).items():
-            # there is a try except block here to deal with schema inconsistencies
-            # during transfer between instances
-            try:
-                field = get_name_field(labels)
-                labels_list = list(labels.values_list(field, flat=True))
-                if len(labels_list) > 0:
-                    print_values = _print_values(labels_list, n=10)
-                    type_str = f": {related_model}" if print_types else ""
-                    labels_msg += f"    .{related_name}{type_str} = {print_values}\n"
-            except Exception:  # noqa: S112
-                continue
+        for related_name, (related_model, labels) in get_labels_as_dict(
+            self, instance=self._state.db
+        ).items():
+            field = get_name_field(labels)
+            labels_list = list(labels.values_list(field, flat=True))
+            if len(labels_list) > 0:
+                print_values = _print_values(labels_list, n=10)
+                type_str = f": {related_model}" if print_types else ""
+                labels_msg += f"    .{related_name}{type_str} = {print_values}\n"
 
     msg = ""
     if labels_msg:
@@ -214,75 +198,68 @@ class LabelManager:
             >>> artifact1.ulabels.set(labels)
             >>> artifact2.labels.add_from(artifact1)
         """
-        from django.db.utils import ProgrammingError
-
         if transfer_logs is None:
             transfer_logs = {"mapped": [], "transferred": [], "run": None}
         using_key = settings._using_key
-        for related_name, (_, labels) in get_labels_as_dict(data).items():
+        for related_name, (_, labels) in get_labels_as_dict(
+            data, instance=self._host._state.db
+        ).items():
             labels = labels.all()
-            try:
-                if not labels.exists():
-                    continue
-                # look for features
-                data_name_lower = data.__class__.__name__.lower()
-                labels_by_features = defaultdict(list)
-                features = set()
-                _, new_labels = validate_labels(labels)
-                if len(new_labels) > 0:
-                    transfer_fk_to_default_db_bulk(
-                        new_labels, using_key, transfer_logs=transfer_logs
+            if not labels.exists():
+                continue
+            # look for features
+            data_name_lower = data.__class__.__name__.lower()
+            labels_by_features = defaultdict(list)
+            features = set()
+            _, new_labels = validate_labels(labels)
+            if len(new_labels) > 0:
+                transfer_fk_to_default_db_bulk(
+                    new_labels, using_key, transfer_logs=transfer_logs
+                )
+            for label in labels:
+                # if the link table doesn't follow this convention, we'll ignore it
+                if not hasattr(label, f"links_{data_name_lower}"):
+                    key = None
+                else:
+                    link = getattr(label, f"links_{data_name_lower}").get(
+                        **{f"{data_name_lower}_id": data.id}
                     )
-                for label in labels:
-                    # if the link table doesn't follow this convention, we'll ignore it
-                    if not hasattr(label, f"links_{data_name_lower}"):
-                        key = None
+                    if link.feature is not None:
+                        features.add(link.feature)
+                        key = link.feature.name
                     else:
-                        link = getattr(label, f"links_{data_name_lower}").get(
-                            **{f"{data_name_lower}_id": data.id}
-                        )
-                        if link.feature is not None:
-                            features.add(link.feature)
-                            key = link.feature.name
-                        else:
-                            key = None
-                    label_returned = transfer_to_default_db(
-                        label,
+                        key = None
+                label_returned = transfer_to_default_db(
+                    label,
+                    using_key,
+                    transfer_logs=transfer_logs,
+                    transfer_fk=False,
+                    save=True,
+                )
+                # TODO: refactor return value of transfer to default db
+                if label_returned is not None:
+                    label = label_returned
+                labels_by_features[key].append(label)
+            # treat features
+            _, new_features = validate_labels(list(features))
+            if len(new_features) > 0:
+                transfer_fk_to_default_db_bulk(
+                    new_features, using_key, transfer_logs=transfer_logs
+                )
+                for feature in new_features:
+                    transfer_to_default_db(
+                        feature,
                         using_key,
                         transfer_logs=transfer_logs,
                         transfer_fk=False,
-                        save=True,
                     )
-                    # TODO: refactor return value of transfer to default db
-                    if label_returned is not None:
-                        label = label_returned
-                    labels_by_features[key].append(label)
-                # treat features
-                _, new_features = validate_labels(list(features))
-                if len(new_features) > 0:
-                    transfer_fk_to_default_db_bulk(
-                        new_features, using_key, transfer_logs=transfer_logs
+                save(new_features)
+            if hasattr(self._host, related_name):
+                for feature_name, labels in labels_by_features.items():
+                    if feature_name is not None:
+                        feature_id = Feature.get(name=feature_name).id
+                    else:
+                        feature_id = None
+                    getattr(self._host, related_name).add(
+                        *labels, through_defaults={"feature_id": feature_id}
                     )
-                    for feature in new_features:
-                        transfer_to_default_db(
-                            feature,
-                            using_key,
-                            transfer_logs=transfer_logs,
-                            transfer_fk=False,
-                        )
-                    save(new_features)
-                if hasattr(self._host, related_name):
-                    for feature_name, labels in labels_by_features.items():
-                        if feature_name is not None:
-                            feature_id = Feature.get(name=feature_name).id
-                        else:
-                            feature_id = None
-                        getattr(self._host, related_name).add(
-                            *labels, through_defaults={"feature_id": feature_id}
-                        )
-            # ProgrammingError is raised when schemas don't match between source and target instances
-            except ProgrammingError:
-                logger.warning(
-                    f"{related_name} labels cannot be transferred because schema module does not exist in target instance: {labels}"
-                )
-                continue

lamindb/core/_settings.py

@@ -143,6 +143,11 @@ class Settings:
             path, kwargs = path_kwargs, {}
         set_managed_storage(path, **kwargs)
 
+    @property
+    def cache_dir(self) -> UPath:
+        """Cache root, a local directory to cache cloud files."""
+        return ln_setup.settings.cache_dir
+
     @property
     def storage_local(self) -> StorageSettings:
         """An additional local default storage (a path to its root).

lamindb/core/_sync_git.py

@@ -16,7 +16,7 @@ class BlobHashNotFound(SystemExit):
 
 def get_git_repo_from_remote() -> Path:
     repo_url = settings.sync_git_repo
-    repo_dir = setup_settings.storage.cache_dir / repo_url.split("/")[-1]
+    repo_dir = setup_settings.cache_dir / repo_url.split("/")[-1]
     if repo_dir.exists():
         logger.warning(f"git repo {repo_dir} already exists locally")
         return repo_dir
@@ -26,7 +26,7 @@ def get_git_repo_from_remote() -> Path:
     result = subprocess.run(
         ["git", "clone", "--depth", "10", f"{repo_url}.git"],
         capture_output=True,
-        cwd=setup_settings.storage.cache_dir,
+        cwd=setup_settings.cache_dir,
     )
     if result.returncode != 0 or not repo_dir.exists():
         raise RuntimeError(result.stderr.decode())

lamindb/core/_track_environment.py

@@ -11,7 +11,7 @@ if TYPE_CHECKING:
 
 
 def track_environment(run: Run) -> None:
-    filepath = ln_setup.settings.storage.cache_dir / f"run_env_pip_{run.uid}.txt"
+    filepath = ln_setup.settings.cache_dir / f"run_env_pip_{run.uid}.txt"
     # create a requirements.txt
     # we don't create a conda environment.yml mostly for its slowness
     try:

lamindb/core/exceptions.py

@@ -45,7 +45,7 @@ class ValidationError(SystemExit):
 
 # inspired by Django's DoesNotExist
 # equivalent to SQLAlchemy's NoResultFound
-class DoesNotExist(Exception):
+class DoesNotExist(SystemExit):
     """No record found."""
 
     pass

lamindb/core/schema.py

@@ -1,31 +1,66 @@
 from __future__ import annotations
 
+import lamindb_setup as ln_setup
 from django.db.models import ManyToManyField
+from lamindb_setup._connect_instance import (
+    get_owner_name_from_identifier,
+    load_instance_settings,
+)
+from lamindb_setup.core._settings_store import instance_settings_file
 from lnschema_core.models import Feature, FeatureSet, LinkORM, Record
 
 
-def dict_schema_name_to_model_name(registry: type[Record]) -> dict[str, Record]:
+def get_schemas_modules(instance: str | None) -> set[str]:
+    if instance is None or instance == "default":
+        schema_modules = set(ln_setup.settings.instance.schema)
+        schema_modules.add("core")
+        return schema_modules
+    owner, name = get_owner_name_from_identifier(instance)
+    settings_file = instance_settings_file(name, owner)
+    if settings_file.exists():
+        schema = set(load_instance_settings(settings_file).schema)
+    else:
+        cache_filepath = (
+            ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
+        )
+        if cache_filepath.exists():
+            schema = set(cache_filepath.read_text().split("\n")[1].split(","))
+        else:
+            raise ValueError(f"Instance {instance} not found")
+    shared_schema_modules = set(ln_setup.settings.instance.schema).intersection(schema)
+    shared_schema_modules.add("core")
+    return shared_schema_modules
+
+
+def dict_schema_name_to_model_name(
+    registry: type[Record], instance: str | None = None
+) -> dict[str, Record]:
+    schema_modules = get_schemas_modules(instance)
     d: dict = {
         i.related_model.__get_name_with_schema__(): i.related_model
         for i in registry._meta.related_objects
         if i.related_name is not None
+        and i.related_model.__get_schema_name__() in schema_modules
     }
     d.update(
         {
             i.related_model.__get_name_with_schema__(): i.related_model
             for i in registry._meta.many_to_many
             if i.name is not None
+            and i.related_model.__get_schema_name__() in schema_modules
         }
     )
     return d
 
 
 def dict_related_model_to_related_name(
-    registry: type[Record], links: bool = False
+    registry: type[Record], links: bool = False, instance: str | None = None
 ) -> dict[str, str]:
     def include(model: Record):
         return not links != issubclass(model, LinkORM)
 
+    schema_modules = get_schemas_modules(instance)
+
     related_objects = registry._meta.related_objects + registry._meta.many_to_many
     d: dict = {
         record.related_model.__get_name_with_schema__(): (
@@ -34,7 +69,11 @@ def dict_related_model_to_related_name(
             else record.name
         )
         for record in related_objects
-        if (record.name is not None and include(record.related_model))
+        if (
+            record.name is not None
+            and include(record.related_model)
+            and record.related_model.__get_schema_name__() in schema_modules
+        )
     }
     return d
 

lamindb/integrations/_vitessce.py

@@ -8,6 +8,7 @@ import lamindb_setup as ln_setup
 from lamin_utils import logger
 
 from lamindb._artifact import Artifact
+from lamindb._collection import Collection
 from lamindb._run import Run
 from lamindb._transform import Transform
 
@@ -20,14 +21,21 @@ if TYPE_CHECKING:
 def save_vitessce_config(
     vitessce_config: VitessceConfig, description: str | None = None
 ) -> Artifact:
-    """Validates and saves a ``VitessceConfig`` object.
+    """Validates and saves a `VitessceConfig` object.
+
+    If the `VitessceConfig` object references multiple artifacts, automatically
+    creates a `Collection` and displays the "Vitessce button" next to it.
 
     Guide: :doc:`docs:vitessce`.
 
     Args:
-        vitessce_config (``VitessceConfig``): A `VitessceConfig` object.
-        description: A description for the `VitessceConfig` artifact.
+        vitessce_config: A `VitessceConfig` object.
+        description: A description for the `VitessceConfig` object. Is used as
+            `name` for a `Collection` in case the `VitessceConfig` object
+            references multiple artifacts.
 
+    .. versionchanged:: 0.76.12
+        Now assumes `vitessce-python >= 3.4.0`, which allows passing artifacts within `VitessceConfig`.
     .. versionchanged:: 0.75.1
         Now displays the "Vitessce button" on the hub next to the dataset. It additionally keeps displaying it next to the configuration file.
     .. versionchanged:: 0.70.2
@@ -40,68 +48,54 @@ def save_vitessce_config(
 
     assert isinstance(vitessce_config, VitessceConfig)  # noqa: S101
     vc_dict = vitessce_config.to_dict()
-    valid_composite_zarr_suffixes = [
-        suffix for suffix in VALID_SUFFIXES.COMPOSITE if suffix.endswith(".zarr")
-    ]
-    # validate
-    dataset_artifacts = []
-    assert vc_dict["datasets"]  # noqa: S101
-    for vitessce_dataset in vc_dict["datasets"]:
-        # didn't find good ways to violate the below, hence using plain asserts
-        # without user feedback
-        assert "files" in vitessce_dataset  # noqa: S101
-        assert vitessce_dataset["files"]  # noqa: S101
-        for file in vitessce_dataset["files"]:
-            if "url" not in file:
-                raise ValueError("Each file must have a 'url' key.")
-            s3_path = file["url"]
-            s3_path_last_element = s3_path.split("/")[-1]
-            # now start with attempting to strip the composite suffix candidates
-            for suffix in valid_composite_zarr_suffixes:
-                s3_path_last_element = s3_path_last_element.replace(suffix, "")
-            # in case there was no hit, strip plain ".zarr"
-            artifact_stem_uid = s3_path_last_element.replace(".zarr", "")
-            # if there is still a "." in string, raise an error
-            if "." in artifact_stem_uid:
-                raise ValueError(
-                    f"Suffix should be '.zarr' or one of {valid_composite_zarr_suffixes}. Inspect your path {s3_path}"
-                )
-            artifact = Artifact.filter(uid__startswith=artifact_stem_uid).one_or_none()
-            if artifact is None:
-                raise ValueError(
-                    f"Could not find dataset with stem uid '{artifact_stem_uid}' in lamindb: {vitessce_dataset}. Did you follow https://docs.lamin.ai/vitessce? It appears the AWS S3 path doesn't encode a lamindb uid."
-                )
-            else:
-                dataset_artifacts.append(artifact)
+    try:
+        url_to_artifact_dict = vitessce_config.get_artifacts()
+    except AttributeError as e:
+        raise SystemExit(
+            "save_vitessce_config() requires vitessce>=3.4.0: pip install vitessce>=3.4.0"
+        ) from e
+    dataset_artifacts = list(url_to_artifact_dict.values())
+    message = "\n".join([artifact.__repr__() for artifact in dataset_artifacts])
+    logger.important(f"VitessceConfig references these artifacts:\n{message}")
+    assert len(dataset_artifacts) > 0  # noqa: S101
+
     # the below will be replaced with a `ln.tracked()` decorator soon
-    with logger.mute():
-        transform = Transform(
-            uid="kup03MJBsIVa0001",
-            name="save_vitessce_config",
-            type="function",
-            version="2",
-        ).save()
+    transform = Transform(
+        uid="kup03MJBsIVa0002",
+        name="save_vitessce_config",
+        type="function",
+        version="3",
+    ).save()
     run = Run(transform=transform).save()
+    run.input_artifacts.set(dataset_artifacts)
+    collection = None
     if len(dataset_artifacts) > 1:
         # if we have more datasets, we should create a collection
         # and attach an action to the collection
-        raise NotImplementedError
-    run.input_artifacts.set(dataset_artifacts)
+        collection = Collection(dataset_artifacts, name=description).save()
+
     # create a JSON export
-    config_file_local_path = (
-        ln_setup.settings.storage.cache_dir / "config.vitessce.json"
-    )
+    config_file_local_path = ln_setup.settings.cache_dir / "config.vitessce.json"
     with open(config_file_local_path, "w") as file:
         json.dump(vc_dict, file)
     vitessce_config_artifact = Artifact(
         config_file_local_path, description=description, run=run
     ).save()
-    # we have one and only one dataset artifact, hence the following line is OK
-    dataset_artifacts[0]._actions.add(vitessce_config_artifact)
     slug = ln_setup.settings.instance.slug
     logger.important(
-        f"go to: https://lamin.ai/{slug}/artifact/{vitessce_config_artifact.uid}"
+        f"VitessceConfig: https://lamin.ai/{slug}/artifact/{vitessce_config_artifact.uid}"
     )
+    if collection is None:
+        # we have one and only one dataset artifact, hence the following line is OK
+        dataset_artifacts[0]._actions.add(vitessce_config_artifact)
+        logger.important(
+            f"Dataset: https://lamin.ai/{slug}/artifact/{dataset_artifacts[0].uid}"
+        )
+    else:
+        collection._actions.add(vitessce_config_artifact)
+        logger.important(
+            f"Collection: https://lamin.ai/{slug}/collection/{collection.uid}"
+        )
     run.finished_at = datetime.now(timezone.utc)
     run.save()
     return vitessce_config_artifact

{lamindb-0.76.11.dist-info → lamindb-0.76.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lamindb
-Version: 0.76.11
+Version: 0.76.13
 Summary: A data framework for biology.
 Author-email: Lamin Labs <open-source@lamin.ai>
 Requires-Python: >=3.9
@@ -8,10 +8,10 @@ Description-Content-Type: text/markdown
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
-Requires-Dist: lnschema_core==0.74.6
-Requires-Dist: lamindb_setup==0.77.7
+Requires-Dist: lnschema_core==0.75.0
 Requires-Dist: lamin_utils==0.13.6
-Requires-Dist: lamin_cli==0.17.8
+Requires-Dist: lamin_cli==0.19.0
+Requires-Dist: lamindb_setup
 Requires-Dist: rapidfuzz
 Requires-Dist: pyarrow
 Requires-Dist: typing_extensions!=4.6.0
@@ -23,7 +23,7 @@ Requires-Dist: pandas
 Requires-Dist: graphviz
 Requires-Dist: psycopg2-binary
 Requires-Dist: lamindb_setup[aws] ; extra == "aws"
-Requires-Dist: bionty==0.51.1 ; extra == "bionty"
+Requires-Dist: bionty==0.51.2 ; extra == "bionty"
 Requires-Dist: line_profiler ; extra == "dev"
 Requires-Dist: pre-commit ; extra == "dev"
 Requires-Dist: nox ; extra == "dev"

{lamindb-0.76.11.dist-info → lamindb-0.76.13.dist-info}/RECORD

@@ -1,39 +1,39 @@
-lamindb/__init__.py,sha256=-uf_cdV7PtdeKSV5FnhmeJrYFFMu4pTV4WgjQTXFb4I,2278
-lamindb/_artifact.py,sha256=kbAQp65KqskAnwx8kBBzh2Jb7HRhVBAQJD4xapj57rk,45011
+lamindb/__init__.py,sha256=h_byT1s_9NrqH157lvPgG336CTBqGzIIJNlNU7MKWQE,2278
+lamindb/_artifact.py,sha256=AHyKZ_D_qMGtywAklo42je8BZB-VBqQ-ZTaI9AB_Yxs,44905
 lamindb/_can_validate.py,sha256=1pUavLwZ_yPAtbVYKOGYUHaPxlJGZ246qZ0e-4ZUDSc,19552
-lamindb/_collection.py,sha256=TSkJ3z0axRAFrV2PvZf1YMz7NXWLX3hYoNQ48l4NoyM,14129
+lamindb/_collection.py,sha256=ZQ45_9n0komz1y8l_vzZ-cRn-ghinE0Izl889Mk-TSA,14249
 lamindb/_curate.py,sha256=KpEP0-9nQUmiRn6z7fiGs6BmQdpqSg3QPlAgV-S9_wA,58839
 lamindb/_feature.py,sha256=nZhtrH0ssoNls-hV-dkwfK9sKypg2El59R9qfarxfUE,5340
-lamindb/_feature_set.py,sha256=lHKATvs8NagaaHwsWqi4XMTPTNKsGdM-6ZRctTHHSNc,8130
-lamindb/_filter.py,sha256=NMxIX67gYqN7n3lA4XL6hRgAaAFhpwnwxm3vBA5XGlU,683
-lamindb/_finish.py,sha256=yoVmgaUx5SBKMlA_wUKsJhNmUjtOD65l-4CZ3oXXNvk,9570
+lamindb/_feature_set.py,sha256=JQSP-YLam1KW-rDzly5Dm4IYVL2A6ec7ufIf6iCc2W8,8169
+lamindb/_filter.py,sha256=Pf9NHV4gm7NOC0Frtvx4W7nvwt2EowOP74DwppyXAZs,635
+lamindb/_finish.py,sha256=VMAmxCUFmTKIMSCx7LEh4QAnWDeue6MeUAAzkMVEYMU,9546
 lamindb/_from_values.py,sha256=iqcR8T8i9VZpnn09W441zW-djhWMh8EZj7XFJq9jP2k,14211
 lamindb/_is_versioned.py,sha256=5lAnhTboltFkZCKVRV1uxkm0OCjJz_HKi3yQq_vEuMs,1306
-lamindb/_parents.py,sha256=eMavdd6IO6STOVJSlR2TzdRtx6sKYDKsMOtlR3DZlgQ,15599
-lamindb/_query_manager.py,sha256=Ipe85HL31DDwMbC8CN_1Svbwk48a_DUh_INGQdZL08I,4222
-lamindb/_query_set.py,sha256=qaOgVc9zGiB2iRyJcUplPmRbgezy4tgubNXS25REaN8,12724
-lamindb/_record.py,sha256=puPMZDY1GO-DY02CDbOScTHwXQrUV7BFQfrig8b21Lk,23300
+lamindb/_parents.py,sha256=KMBUfCLNqjmFzOdZIXaUFqDPeEpWP28MCkHHPq887h8,16341
+lamindb/_query_manager.py,sha256=pmPhJQ85-7XeAU9TFv6LPGi9F7dBgztZgZcXz33HYJM,3710
+lamindb/_query_set.py,sha256=81y1c-Y-PGCmqc64WizlCiGTbsrApsajtX2xj7xrsMo,12730
+lamindb/_record.py,sha256=LkKtDxqlTq43UlAiJ96_nbpjj9eQbU4N3HpfBVfImJo,23395
 lamindb/_run.py,sha256=K_5drpLn3D7y3XtZ3vtAw35rG5RCSvB4bXQZx4ESSI0,1964
-lamindb/_save.py,sha256=hOBby87v1_kC2Ixi8f19DgeznlKa8cihyWA7qMUZdtM,11384
+lamindb/_save.py,sha256=BCaSFnANYPxTqL5gw7Hrh_9kz7SDyOxrJV2KW6rXqts,11366
 lamindb/_storage.py,sha256=GBVChv-DHVMNEBJL5l_JT6B4RDhZ6NnwgzmUICphYKk,413
 lamindb/_transform.py,sha256=wZDkY8lp4d_OsO5a7rLs1RamkDzBXZSLaWJU34zRnmA,4728
 lamindb/_ulabel.py,sha256=XDSdZBXX_ki5s1vOths3MjF2x5DPggBR_PV_KF4SGyg,1611
 lamindb/_utils.py,sha256=LGdiW4k3GClLz65vKAVRkL6Tw-Gkx9DWAdez1jyA5bE,428
 lamindb/_view.py,sha256=4Ln2ItTb3857PAI-70O8eJYqoTJ_NNFc7E_wds6OGns,2412
 lamindb/core/__init__.py,sha256=57AXQ286eOX2_o5HUeqIFJrfqN-OZ_E7FVHd3Xm5oOk,1483
-lamindb/core/_context.py,sha256=TD5k0F-igJRwWBjXMaw3Lh3WtgtY3GLl_a7dZ7GHUu4,22639
+lamindb/core/_context.py,sha256=dI3z7fCMRPC3IMb7-EIaQYhacSZBA4HfLVFyoJtVL7I,22900
 lamindb/core/_data.py,sha256=P0vlbw_UQp9UDNMmUo9YFxqurcWtMaKPWCT12IRA2C0,19672
-lamindb/core/_django.py,sha256=mqZ0WhTakLDrGVp3MVI6RNfu8kZ2L5BiEnMwXnkfsG0,6760
-lamindb/core/_feature_manager.py,sha256=jRdBVlWE5GA9vcbiiT54WL-yix4Dptbe-YtxzayvUr0,37319
-lamindb/core/_label_manager.py,sha256=GoluSFk_z1c1fZw8OGKkaIURWgognEsOHCo9mzigd-A,11108
+lamindb/core/_django.py,sha256=yeMPp1n9WrFmEjVRdavfpVqAolPLd24RseTQlvsK67w,7157
+lamindb/core/_feature_manager.py,sha256=yH6HGF_c0NwIE6hxcMUZdZrokx75Kz-54d_3JhyCglQ,39020
+lamindb/core/_label_manager.py,sha256=bhD6krOrf0SWXfCzhFsEA-7h0ZLJ59YSPxWnlq7DZiE,9991
 lamindb/core/_mapped_collection.py,sha256=M50haewVAFONeF71QQbzD09L8lVZCL1hyf0W87jKE5U,24575
-lamindb/core/_settings.py,sha256=f7TCIx9cYFpLH9ja7OCMLpAgrOJRZUP8Rr_xJKToMlk,5979
-lamindb/core/_sync_git.py,sha256=qc0yfPyKeG4uuNT_3qsv-mkIMqhLFqfXNeNVO49vV00,4547
-lamindb/core/_track_environment.py,sha256=STzEVUzOeUEWdX7WDJUkKH4u08k7eupRX6AXQwoVt14,828
-lamindb/core/exceptions.py,sha256=JowyzEXRd2DivS-LQHi46hWNKg1lXMjgcp1soNFB0eI,1635
+lamindb/core/_settings.py,sha256=6jNadlQdimxCsKR2ZyUD0YJYzOdubTnKktki-MqEWqQ,6137
+lamindb/core/_sync_git.py,sha256=lIgl6YfpH4rCFT1WILAp7zlemZfxog1d0zp3cX0KIZw,4531
+lamindb/core/_track_environment.py,sha256=Ywzg_sJ7guI1dcsN7h5orce9VdYl8VGVE3OLITlHBXQ,820
+lamindb/core/exceptions.py,sha256=0B36kOVo-Dik5KbSKvy5GPuMjUfhVb99dJwXl_J0ldo,1636
 lamindb/core/fields.py,sha256=47Jmh3efUr5ZscgimR_yckY-I3cNf8ScLutbwKCK3j4,162
 lamindb/core/loaders.py,sha256=KMTkDa73jkRVvI9uc5Fgr0t6mq22cAxBwhSlUZKUaBg,4016
-lamindb/core/schema.py,sha256=KiYQn_8fokSMztTNDe6qUocZzKXWxU32H-YChNJv51A,1877
+lamindb/core/schema.py,sha256=Y1tGn93B236PtnYZkpgTNFgTXBcVujPM1qh1kNG6Nbs,3441
 lamindb/core/types.py,sha256=uVBqSVLoQaTkqP9nqsJhwU6yYnx8H5e6-ZxrB6vpOOw,265
 lamindb/core/versioning.py,sha256=KUpd94F5QpbDxx9eKgZwrpPyQpm9YeHVedrTEO2a_mI,4839
 lamindb/core/datasets/__init__.py,sha256=zRP98oqUAaXhqWyKMiH0s_ImVIuNeziQQ2kQ_t0f-DI,1353
@@ -52,10 +52,10 @@ lamindb/core/subsettings/__init__.py,sha256=KFHPzIE7f7Bj4RgMjGQF4CjTdHVG_VNFBrCn
 lamindb/core/subsettings/_creation_settings.py,sha256=54mfMH_osC753hpxcl7Dq1rwBD2LHnWveXtQpkLBITE,1194
 lamindb/core/subsettings/_transform_settings.py,sha256=4YbCuZtJo6zdytl6UQR4GvdDkTtT6SRBqVzofGzNOt8,583
 lamindb/integrations/__init__.py,sha256=RWGMYYIzr8zvmNPyVB4m-p4gMDhxdRbjES2Ed23OItw,215
-lamindb/integrations/_vitessce.py,sha256=S51wl7iF2QvQmrNcZ9yDdqTtcn_AAzuh0i5axKwQ2sM,4560
+lamindb/integrations/_vitessce.py,sha256=uPl45_w4Uu9_BhpBDDVonC1nDOuAnB7DAnzi5w5bZAE,4032
 lamindb/setup/__init__.py,sha256=OwZpZzPDv5lPPGXZP7-zK6UdO4FHvvuBh439yZvIp3A,410
 lamindb/setup/core/__init__.py,sha256=SevlVrc2AZWL3uALbE5sopxBnIZPWZ1IB0NBDudiAL8,167
-lamindb-0.76.11.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-lamindb-0.76.11.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
-lamindb-0.76.11.dist-info/METADATA,sha256=ZbXuWNskfvWAFEfX7FKkc5zakPnKW2IOSTx8rTZ9dag,2369
-lamindb-0.76.11.dist-info/RECORD,,
+lamindb-0.76.13.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+lamindb-0.76.13.dist-info/WHEEL,sha256=EZbGkh7Ie4PoZfRQ8I0ZuP9VklN_TvcZ6DSE5Uar4z4,81
+lamindb-0.76.13.dist-info/METADATA,sha256=Vo8AcZfSEBwW3NJsFndztG1b2fAVSquWw2OENmncc8M,2361
+lamindb-0.76.13.dist-info/RECORD,,