lamindb 1.0.4__py3-none-any.whl → 1.1.0__py3-none-any.whl

lamindb/core/_context.py

@@ -19,15 +19,14 @@ from lamindb.base import ids
 from lamindb.base.ids import base62_12
 from lamindb.models import Run, Transform, format_field_value
 
-from ._settings import settings
-from ._sync_git import get_transform_reference_from_git_repo
-from ._track_environment import track_environment
-from .exceptions import (
+from ..errors import (
     InconsistentKey,
-    NotebookNotSaved,
     TrackNotCalled,
     UpdateContext,
 )
+from ._settings import settings
+from ._sync_git import get_transform_reference_from_git_repo
+from ._track_environment import track_environment
 from .versioning import bump_version as bump_version_function
 from .versioning import increment_base62, message_update_key_in_version_family
 
@@ -201,6 +200,7 @@ class Context:
         self._logging_message_track: str = ""
         self._logging_message_imports: str = ""
         self._stream_tracker: LogStreamTracker = LogStreamTracker()
+        self._is_finish_retry: bool = False
 
     @property
     def transform(self) -> Transform | None:
@@ -307,11 +307,15 @@ class Context:
                 ) = self._track_source_code(path=path)
             if description is None:
                 description = self._description
+            # temporarily until the hub displays the key by default
+            # populate the description with the filename again
+            if description is None:
+                description = self._path.name
             self._create_or_load_transform(
                 description=description,
                 transform_ref=transform_ref,
                 transform_ref_type=transform_ref_type,
-                transform_type=transform_type,
+                transform_type=transform_type,  # type: ignore
             )
         else:
             if transform.type in {"notebook", "script"}:
@@ -348,7 +352,7 @@ class Context:
                 self._logging_message_track += f", re-started Run('{run.uid[:8]}...') at {format_field_value(run.started_at)}"
 
         if run is None:  # create new run
-            run = Run(
+            run = Run(  # type: ignore
                 transform=self._transform,
                 params=params,
             )
@@ -494,15 +498,19 @@ class Context:
                     if aux_transform.key in self._path.as_posix():
                         key = aux_transform.key
                         if (
-                            # if the transform source code wasn't yet saved
-                            aux_transform.source_code is None
-                            # if the transform source code is unchanged
-                            # if aux_transform.type == "notebook", we anticipate the user makes changes to the notebook source code
-                            # in an interactive session, hence we *pro-actively bump* the version number by setting `revises`
-                            # in the second part of the if condition even though the source code is unchanged at point of running track()
-                            or (
-                                aux_transform.hash == hash
-                                and aux_transform.type != "notebook"
+                            # has to be the same user
+                            aux_transform.created_by_id == ln_setup.settings.user.id
+                            and (
+                                # if the transform source code wasn't yet saved
+                                aux_transform.source_code is None
+                                # if the transform source code is unchanged
+                                # if aux_transform.type == "notebook", we anticipate the user makes changes to the notebook source code
+                                # in an interactive session, hence we *pro-actively bump* the version number by setting `revises`
+                                # in the second part of the if condition even though the source code is unchanged at point of running track()
+                                or (
+                                    aux_transform.hash == hash
+                                    and aux_transform.type != "notebook"
+                                )
                             )
                         ):
                             uid = aux_transform.uid
@@ -514,9 +522,13 @@ class Context:
                                 aux_transform.hash == hash
                                 and aux_transform.type == "notebook"
                             ):
-                                message += " -- notebook source code is unchanged, but anticipating changes during this run"
+                                message += " -- anticipating changes"
                             elif aux_transform.hash != hash:
-                                message += " -- source code changed"
+                                message += ""  # could log "source code changed", but this seems too much
+                            elif (
+                                aux_transform.created_by_id != ln_setup.settings.user.id
+                            ):
+                                message += f" -- {aux_transform.created_by.handle} already works on this draft"
                             message += f", creating new version '{uid}'"
                             revises = aux_transform
                         found_key = True
@@ -575,7 +587,7 @@ class Context:
             assert key is not None  # noqa: S101
             raise_update_context = False
             try:
-                transform = Transform(
+                transform = Transform(  # type: ignore
                     uid=self.uid,
                     version=self.version,
                     description=description,
@@ -613,7 +625,7 @@ class Context:
                 and not transform_was_saved
             ):
                 raise UpdateContext(
-                    f'{transform.created_by.description} ({transform.created_by.handle}) already works on this draft {transform.type}.\n\nPlease create a revision via `ln.track("{uid[:-4]}{increment_base62(uid[-4:])}")` or a new transform with a *different* filedescription and `ln.track("{ids.base62_12()}0000")`.'
+                    f'{transform.created_by.name} ({transform.created_by.handle}) already works on this draft {transform.type}.\n\nPlease create a revision via `ln.track("{uid[:-4]}{increment_base62(uid[-4:])}")` or a new transform with a *different* filedescription and `ln.track("{ids.base62_12()}0000")`.'
                 )
             # check whether transform source code was already saved
             if transform_was_saved:
@@ -648,12 +660,12 @@ class Context:
 
         - writes a timestamp: `run.finished_at`
         - saves the source code: `transform.source_code`
+        - saves a run report: `run.report`
 
         When called in the last cell of a notebook:
 
+        - prompts to save the notebook in your editor right before
         - prompts for user input if not consecutively executed
-        - requires to save the notebook in your editor right before
-        - saves a run report: `run.report`
 
         Args:
             ignore_non_consecutive: Whether to ignore if a notebook was non-consecutively executed.
@@ -670,8 +682,6 @@ class Context:
 
         """
         from lamindb._finish import (
-            get_save_notebook_message,
-            get_seconds_since_modified,
             save_context_core,
         )
 
@@ -686,24 +696,17 @@ class Context:
             self.run.save()
             # nothing else to do
             return None
-        if is_run_from_ipython:  # notebooks
-            import nbproject
-
-            # it might be that the user modifies the title just before ln.finish()
-            if (
-                nbproject_title := nbproject.meta.live.title
-            ) != self.transform.description:
-                self.transform.description = nbproject_title
-                self.transform.save()
-            if get_seconds_since_modified(self._path) > 2 and not ln_setup._TESTING:
-                raise NotebookNotSaved(get_save_notebook_message())
-        save_context_core(
+        return_code = save_context_core(
             run=self.run,
             transform=self.run.transform,
             filepath=self._path,
             finished_at=True,
             ignore_non_consecutive=ignore_non_consecutive,
+            is_retry=self._is_finish_retry,
         )
+        if return_code == "retry":
+            self._is_finish_retry = True
+            return None
         if self.transform.type != "notebook":
             self._stream_tracker.finish()
         # reset the context attributes so that somebody who runs `track()` after finish

lamindb/core/_data.py

@@ -21,6 +21,8 @@ from lamindb.models import (
     record_repr,
 )
 
+from .._tracked import get_current_tracked_run
+from ..errors import ValidationError
 from ._context import context
 from ._django import get_artifact_with_related, get_related_model
 from ._feature_manager import (
@@ -28,7 +30,6 @@ from ._feature_manager import (
     get_host_id_field,
     get_label_links,
 )
-from .exceptions import ValidationError
 from .relations import (
     dict_module_name_to_model_name,
     dict_related_model_to_related_name,
@@ -45,9 +46,12 @@ WARNING_RUN_TRANSFORM = "no run & transform got linked, call `ln.track()` & re-r
 WARNING_NO_INPUT = "run input wasn't tracked, call `ln.track()` and re-run"
 
 
+# also see current_run() in core._data
 def get_run(run: Run | None) -> Run | None:
     if run is None:
-        run = context.run
+        run = get_current_tracked_run()
+        if run is None:
+            run = context.run
         if run is None and not settings.creation.artifact_silence_missing_run_warning:
             logger.warning(WARNING_RUN_TRANSFORM)
     # suppress run by passing False
@@ -56,26 +60,26 @@ def get_run(run: Run | None) -> Run | None:
     return run
 
 
-def save_staged__schemas_m2m(self: Artifact | Collection) -> None:
-    if hasattr(self, "_staged__schemas_m2m"):
+def save_staged_feature_sets(self: Artifact | Collection) -> None:
+    if hasattr(self, "_staged_feature_sets"):
         from lamindb.core._feature_manager import get_schema_by_slot_
 
-        existing_staged__schemas_m2m = get_schema_by_slot_(self)
-        saved_staged__schemas_m2m = {}
-        for key, schema in self._staged__schemas_m2m.items():
+        existing_staged_feature_sets = get_schema_by_slot_(self)
+        saved_staged_feature_sets = {}
+        for key, schema in self._staged_feature_sets.items():
             if isinstance(schema, Schema) and schema._state.adding:
                 schema.save()
-                saved_staged__schemas_m2m[key] = schema
-            if key in existing_staged__schemas_m2m:
+                saved_staged_feature_sets[key] = schema
+            if key in existing_staged_feature_sets:
                 # remove existing feature set on the same slot
-                self._schemas_m2m.remove(existing_staged__schemas_m2m[key])
-        if len(saved_staged__schemas_m2m) > 0:
-            s = "s" if len(saved_staged__schemas_m2m) > 1 else ""
+                self.feature_sets.remove(existing_staged_feature_sets[key])
+        if len(saved_staged_feature_sets) > 0:
+            s = "s" if len(saved_staged_feature_sets) > 1 else ""
             display_schema_keys = ",".join(
-                f"'{key}'" for key in saved_staged__schemas_m2m.keys()
+                f"'{key}'" for key in saved_staged_feature_sets.keys()
             )
             logger.save(
-                f"saved {len(saved_staged__schemas_m2m)} feature set{s} for slot{s}:"
+                f"saved {len(saved_staged_feature_sets)} feature set{s} for slot{s}:"
                 f" {display_schema_keys}"
             )
 
@@ -84,16 +88,16 @@ def save_schema_links(self: Artifact | Collection) -> None:
     from lamindb._save import bulk_create
 
     Data = self.__class__
-    if hasattr(self, "_staged__schemas_m2m"):
+    if hasattr(self, "_staged_feature_sets"):
         links = []
         host_id_field = get_host_id_field(self)
-        for slot, schema in self._staged__schemas_m2m.items():
+        for slot, schema in self._staged_feature_sets.items():
             kwargs = {
                 host_id_field: self.id,
                 "schema_id": schema.id,
                 "slot": slot,
             }
-            links.append(Data._schemas_m2m.through(**kwargs))
+            links.append(Data.feature_sets.through(**kwargs))
         bulk_create(links, ignore_conflicts=True)
 
 
@@ -182,7 +186,7 @@ def _describe_sqlite(self: Artifact | Collection, print_types: bool = False):
         if isinstance(self, (Collection, Artifact)):
             many_to_many_fields.append("input_of_runs")
         if isinstance(self, Artifact):
-            many_to_many_fields.append("_schemas_m2m")
+            many_to_many_fields.append("feature_sets")
         self = (
             self.__class__.objects.using(self._state.db)
             .prefetch_related(*many_to_many_fields)
@@ -335,10 +339,10 @@ def add_labels(
     else:
         validate_feature(feature, records)  # type:ignore
         records_by_registry = defaultdict(list)
-        _schemas_m2m = self._schemas_m2m.filter(itype="Feature").all()
+        feature_sets = self.feature_sets.filter(itype="Feature").all()
         internal_features = set()  # type: ignore
-        if len(_schemas_m2m) > 0:
-            for schema in _schemas_m2m:
+        if len(feature_sets) > 0:
+            for schema in feature_sets:
                 internal_features = internal_features.union(
                     set(schema.members.values_list("name", flat=True))
                 )  # type: ignore
@@ -357,7 +361,7 @@ def add_labels(
                         f"Feature {feature.name} needs dtype='cat' for label annotation, currently has dtype='{feature.dtype}'"
                     )
                 if feature.dtype == "cat":
-                    feature.dtype = f"cat[{registry_name}]"
+                    feature.dtype = f"cat[{registry_name}]"  # type: ignore
                     feature.save()
                 elif registry_name not in feature.dtype:
                     new_dtype = feature.dtype.rstrip("]") + f"|{registry_name}]"
@@ -386,13 +390,13 @@ def _track_run_input(
     is_run_input: bool | Run | None = None,
     run: Run | None = None,
 ):
-    # this is an internal hack right now for project-flow, but we can allow this
-    # for the user in the future
     if isinstance(is_run_input, Run):
         run = is_run_input
         is_run_input = True
     elif run is None:
-        run = context.run
+        run = get_current_tracked_run()
+        if run is None:
+            run = context.run
     # consider that data is an iterable of Data
     data_iter: Iterable[Artifact] | Iterable[Collection] = (
         [data] if isinstance(data, (Artifact, Collection)) else data

lamindb/core/_describe.py

@@ -76,7 +76,7 @@ def describe_header(self: Artifact | Collection | Run) -> Tree:
         if self._branch_code == 0:
             logger.warning("This artifact is hidden.")
         elif self._branch_code == -1:
-            logger.warning("This artifact is the trash.")
+            logger.warning("This artifact is in the trash.")
     # initialize tree
     suffix = self.suffix if hasattr(self, "suffix") and self.suffix else ""
     accessor = self.otype if hasattr(self, "otype") and self.otype else ""

lamindb/core/_django.py

@@ -105,7 +105,7 @@ def get_artifact_with_related(
 
     if include_schema:
         annotations["schemas"] = Subquery(
-            model._schemas_m2m.through.objects.filter(artifact=OuterRef("pk"))
+            model.feature_sets.through.objects.filter(artifact=OuterRef("pk"))
             .annotate(
                 data=JSONObject(
                     id=F("id"),

lamindb/core/_feature_manager.py

@@ -33,8 +33,8 @@ from lamindb._record import (
 )
 from lamindb._save import save
 from lamindb._schema import DICT_KEYS_TYPE, Schema
-from lamindb.core.exceptions import DoesNotExist, ValidationError
 from lamindb.core.storage import LocalPathClasses
+from lamindb.errors import DoesNotExist, ValidationError
 from lamindb.models import (
     Artifact,
     Collection,
@@ -96,8 +96,8 @@ def get_schema_by_slot_(host: Artifact | Collection) -> dict:
         return {}
     # if the host is not yet saved
     if host._state.adding:
-        if hasattr(host, "_staged__schemas_m2m"):
-            return host._staged__schemas_m2m
+        if hasattr(host, "_staged_feature_sets"):
+            return host._staged_feature_sets
         else:
             return {}
     host_db = host._state.db
@@ -105,7 +105,7 @@ def get_schema_by_slot_(host: Artifact | Collection) -> dict:
     kwargs = {host_id_field: host.id}
     # otherwise, we need a query
     links_schema = (
-        host._schemas_m2m.through.objects.using(host_db)
+        host.feature_sets.through.objects.using(host_db)
         .filter(**kwargs)
         .select_related("schema")
     )
@@ -118,7 +118,7 @@ def get_label_links(
     host_id_field = get_host_id_field(host)
     kwargs = {host_id_field: host.id, "feature_id": feature.id}
     link_records = (
-        getattr(host, host.features._accessor_by_registry[registry])
+        getattr(host, host.features._accessor_by_registry[registry])  # type: ignore
         .through.objects.using(host._state.db)
         .filter(**kwargs)
     )
@@ -128,14 +128,14 @@ def get_label_links(
 def get_schema_links(host: Artifact | Collection) -> QuerySet:
     host_id_field = get_host_id_field(host)
     kwargs = {host_id_field: host.id}
-    links_schema = host._schemas_m2m.through.objects.filter(**kwargs)
+    links_schema = host.feature_sets.through.objects.filter(**kwargs)
     return links_schema
 
 
 def get_link_attr(link: LinkORM | type[LinkORM], data: Artifact | Collection) -> str:
     link_model_name = link.__class__.__name__
     if link_model_name in {"Registry", "ModelBase"}:  # we passed the type of the link
-        link_model_name = link.__name__
+        link_model_name = link.__name__  # type: ignore
     return link_model_name.replace(data.__class__.__name__, "").lower()
 
 
@@ -348,10 +348,10 @@ def describe_features(
 
     internal_feature_names: dict[str, str] = {}
     if isinstance(self, Artifact):
-        _schemas_m2m = self._schemas_m2m.filter(itype="Feature").all()
+        feature_sets = self.feature_sets.filter(itype="Feature").all()
         internal_feature_names = {}
-        if len(_schemas_m2m) > 0:
-            for schema in _schemas_m2m:
+        if len(feature_sets) > 0:
+            for schema in feature_sets:
                 internal_feature_names.update(
                     dict(schema.members.values_list("name", "dtype"))
                 )
@@ -466,7 +466,7 @@ def describe_features(
             Text.assemble(
                 ("Dataset features", "bold bright_magenta"),
                 ("/", "dim"),
-                ("._schemas_m2m", "dim bold"),
+                ("schema", "dim bold"),
             )
         )
         for child in int_features_tree_children:
@@ -500,7 +500,7 @@ def describe_features(
     return tree
 
 
-def parse_staged__schemas_m2m_from_anndata(
+def parse_staged_feature_sets_from_anndata(
     adata: AnnData,
     var_field: FieldAttr | None = None,
     obs_field: FieldAttr = Feature.name,
@@ -524,7 +524,7 @@ def parse_staged__schemas_m2m_from_anndata(
             if adata.X is None
             else convert_pandas_dtype_to_lamin_dtype(adata.X.dtype)
         )
-    _schemas_m2m = {}
+    feature_sets = {}
     if var_field is not None:
         logger.info("parsing feature names of X stored in slot 'var'")
         logger.indent = "   "
@@ -537,7 +537,7 @@ def parse_staged__schemas_m2m_from_anndata(
             raise_validation_error=False,
         )
         if schema_var is not None:
-            _schemas_m2m["var"] = schema_var
+            feature_sets["var"] = schema_var
             logger.save(f"linked: {schema_var}")
         logger.indent = ""
         if schema_var is None:
@@ -552,12 +552,12 @@ def parse_staged__schemas_m2m_from_anndata(
             organism=organism,
         )
         if schema_obs is not None:
-            _schemas_m2m["obs"] = schema_obs
+            feature_sets["obs"] = schema_obs
             logger.save(f"linked: {schema_obs}")
         logger.indent = ""
         if schema_obs is None:
             logger.warning("skip linking features to artifact in slot 'obs'")
-    return _schemas_m2m
+    return feature_sets
 
 
 def is_valid_datetime_str(date_string: str) -> bool | str:
@@ -818,6 +818,8 @@ def _add_values(
         feature_param_field: The field of a reference registry to map keys of the
             dictionary.
     """
+    from .._tracked import get_current_tracked_run
+
     # rename to distinguish from the values inside the dict
     features_values = values
     keys = features_values.keys()
@@ -849,12 +851,20 @@ def _add_values(
             (key, infer_feature_type_convert_json(key, features_values[key]))
             for key in not_validated_keys
         ]
-        hint = "\n".join(
-            [
-                f"  ln.{model_name}(name='{key}', dtype='{dtype}').save(){message}"
-                for key, (dtype, _, message) in not_validated_keys_dtype_message
-            ]
-        )
+        run = get_current_tracked_run()
+        if run is not None:
+            name = f"{run.transform.type}[{run.transform.key}]"
+            type_hint = f"""  {model_name.lower()}_type = ln.{model_name}(name='{name}', is_type=True).save()"""
+            elements = [type_hint]
+            type_kwarg = f", type={model_name.lower()}_type"
+        else:
+            elements = []
+            type_kwarg = ""
+        elements += [
+            f"  ln.{model_name}(name='{key}', dtype='{dtype}'{type_kwarg}).save(){message}"
+            for key, (dtype, _, message) in not_validated_keys_dtype_message
+        ]
+        hint = "\n".join(elements)
         msg = (
             f"These keys could not be validated: {not_validated_keys.tolist()}\n"
             f"Here is how to create a {model_name.lower()}:\n\n{hint}"
@@ -928,7 +938,7 @@ def _add_values(
                 validated_values = values_array[validated]
                 if validated.sum() != len(values):
                     not_validated_values += values_array[~validated].tolist()
-                label_records = ULabel.from_values(validated_values, field="name")
+                label_records = ULabel.from_values(validated_values, field="name")  # type: ignore
                 features_labels["ULabel"] += [
                     (feature, label_record) for label_record in label_records
                 ]
@@ -1012,8 +1022,8 @@ def remove_values(
     if isinstance(feature, str):
         feature = Feature.get(name=feature)
     filter_kwargs = {"feature": feature}
-    if feature.dtype.startswith("cat["):
-        feature_registry = feature.dtype.replace("cat[", "").replace("]", "")
+    if feature.dtype.startswith("cat["):  # type: ignore
+        feature_registry = feature.dtype.replace("cat[", "").replace("]", "")  # type: ignore
         if value is not None:
             assert isinstance(value, Record)  # noqa: S101
             # the below uses our convention for field names in link models
@@ -1071,12 +1081,12 @@ def add_schema(self, schema: Schema, slot: str) -> None:
         "slot": slot,
     }
     link_record = (
-        self._host._schemas_m2m.through.objects.using(host_db)
+        self._host.feature_sets.through.objects.using(host_db)
         .filter(**kwargs)
         .one_or_none()
     )
     if link_record is None:
-        self._host._schemas_m2m.through(**kwargs).save(using=host_db)
+        self._host.feature_sets.through(**kwargs).save(using=host_db)
         if slot in self._schema_by_slot:
             logger.debug(f"replaced existing {slot} feature set")
         self._schema_by_slot_[slot] = schema  # type: ignore
@@ -1101,7 +1111,7 @@ def _add_set_from_df(
         mute=mute,
         organism=organism,
     )
-    self._host._staged__schemas_m2m = {"columns": schema}
+    self._host._staged_feature_sets = {"columns": schema}
     self._host.save()
 
 
@@ -1120,7 +1130,7 @@ def _add_set_from_anndata(
 
     # parse and register features
     adata = self._host.load()
-    _schemas_m2m = parse_staged__schemas_m2m_from_anndata(
+    feature_sets = parse_staged_feature_sets_from_anndata(
         adata,
         var_field=var_field,
         obs_field=obs_field,
@@ -1129,7 +1139,7 @@ def _add_set_from_anndata(
     )
 
     # link feature sets
-    self._host._staged__schemas_m2m = _schemas_m2m
+    self._host._staged_feature_sets = feature_sets
     self._host.save()
 
 
@@ -1150,12 +1160,12 @@ def _add_set_from_mudata(
 
     # parse and register features
     mdata = self._host.load()
-    _schemas_m2m = {}
-    obs_features = Feature.from_values(mdata.obs.columns)
+    feature_sets = {}
+    obs_features = Feature.from_values(mdata.obs.columns)  # type: ignore
     if len(obs_features) > 0:
-        _schemas_m2m["obs"] = Schema(features=obs_features)
+        feature_sets["obs"] = Schema(features=obs_features)
     for modality, field in var_fields.items():
-        modality_fs = parse_staged__schemas_m2m_from_anndata(
+        modality_fs = parse_staged_feature_sets_from_anndata(
             mdata[modality],
             var_field=field,
             obs_field=obs_fields.get(modality, Feature.name),
@@ -1163,22 +1173,22 @@ def _add_set_from_mudata(
             organism=organism,
         )
         for k, v in modality_fs.items():
-            _schemas_m2m[f"['{modality}'].{k}"] = v
+            feature_sets[f"['{modality}'].{k}"] = v
 
-    def unify_staged__schemas_m2m_by_hash(_schemas_m2m):
+    def unify_staged_feature_sets_by_hash(feature_sets):
         unique_values = {}
 
-        for key, value in _schemas_m2m.items():
+        for key, value in feature_sets.items():
             value_hash = value.hash  # Assuming each value has a .hash attribute
             if value_hash in unique_values:
-                _schemas_m2m[key] = unique_values[value_hash]
+                feature_sets[key] = unique_values[value_hash]
             else:
                 unique_values[value_hash] = value
 
-        return _schemas_m2m
+        return feature_sets
 
     # link feature sets
-    self._host._staged__schemas_m2m = unify_staged__schemas_m2m_by_hash(_schemas_m2m)
+    self._host._staged_feature_sets = unify_staged_feature_sets_by_hash(feature_sets)
     self._host.save()
 
 
@@ -1188,7 +1198,7 @@ def _add_from(self, data: Artifact | Collection, transfer_logs: dict = None):
     if transfer_logs is None:
         transfer_logs = {"mapped": [], "transferred": [], "run": None}
     using_key = settings._using_key
-    for slot, schema in data.features._schema_by_slot.items():
+    for slot, schema in data.features._schema_by_slot.items():  # type: ignore
         members = schema.members
         if len(members) == 0:
             continue
@@ -1248,8 +1258,8 @@ def make_external(self, feature: Feature) -> None:
     """
     if not isinstance(feature, Feature):
         raise TypeError("feature must be a Feature record!")
-    _schemas_m2m = Schema.filter(features=feature).all()
-    for fs in _schemas_m2m:
+    feature_sets = Schema.filter(features=feature).all()
+    for fs in feature_sets:
         f = Feature.filter(uid=feature.uid).all()
         features_updated = fs.members.difference(f)
         if len(features_updated) > 0:
@@ -1266,10 +1276,10 @@ def make_external(self, feature: Feature) -> None:
         if len(features_updated) == 0:
             logger.warning(f"deleting empty feature set: {fs}")
             fs.artifacts.set([])
-            fs._artifacts_m2m.set([])
             fs.delete()
 
 
+# mypy: ignore-errors
 FeatureManager.__init__ = __init__
 ParamManager.__init__ = __init__
 FeatureManager.__repr__ = __repr__

lamindb/core/_label_manager.py

@@ -35,7 +35,7 @@ if TYPE_CHECKING:
     from lamindb._query_set import QuerySet
     from lamindb.models import Artifact, Collection, Record
 
-EXCLUDE_LABELS = {"_schemas_m2m"}
+EXCLUDE_LABELS = {"feature_sets"}
 
 
 def _get_labels(
@@ -106,7 +106,7 @@ def describe_labels(
         pad_edge=False,
     )
     for related_name, labels in labels_data.items():
-        if not labels or related_name == "_schemas_m2m":
+        if not labels or related_name == "feature_sets":
             continue
         if isinstance(labels, dict):  # postgres, labels are a dict[id, name]
             print_values = _format_values(labels.values(), n=10, quotes=False)
@@ -286,12 +286,12 @@ class LabelManager:
                 )
                 for feature in new_features:
                     transfer_to_default_db(
-                        feature,
+                        feature,  # type: ignore
                         using_key,
                         transfer_logs=transfer_logs,
                         transfer_fk=False,
                     )
-                save(new_features)
+                save(new_features)  # type: ignore
             if hasattr(self._host, related_name):
                 for feature_name, feature_labels in labels_by_features.items():
                     if feature_name is not None: