lamindb 1.6.2__py3-none-any.whl → 1.7.0__py3-none-any.whl

lamindb/models/save.py

@@ -29,7 +29,11 @@ if TYPE_CHECKING:
     from .artifact import Artifact
 
 
-def save(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False) -> None:
+def save(
+    records: Iterable[SQLRecord],
+    ignore_conflicts: bool | None = False,
+    batch_size: int = 10000,
+) -> None:
     """Bulk save records.
 
     Note:
@@ -44,9 +48,11 @@ def save(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False) ->
     Args:
         records: Multiple :class:`~lamindb.models.SQLRecord` objects.
         ignore_conflicts: If ``True``, do not error if some records violate a
-           unique or another constraint. However, it won't inplace update the id
-           fields of records. If you need records with ids, you need to query
-           them from the database.
+            unique or another constraint. However, it won't inplace update the id
+            fields of records. If you need records with ids, you need to query
+            them from the database.
+        batch_size: Number of records to process in each batch. Defaults to 10000.
+            Large batch sizes can improve performance but may lead to memory issues.
 
     Examples:
 
@@ -81,9 +87,11 @@ def save(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False) ->
         non_artifacts_old, non_artifacts_new = partition(
             lambda r: r._state.adding or r.pk is None, non_artifacts
         )
-        bulk_create(non_artifacts_new, ignore_conflicts=ignore_conflicts)
+        bulk_create(
+            non_artifacts_new, ignore_conflicts=ignore_conflicts, batch_size=batch_size
+        )
         if non_artifacts_old:
-            bulk_update(non_artifacts_old)
+            bulk_update(non_artifacts_old, batch_size=batch_size)
         non_artifacts_with_parents = [
             r for r in non_artifacts_new if hasattr(r, "_parents")
         ]
@@ -97,6 +105,11 @@ def save(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False) ->
     if artifacts:
         with transaction.atomic():
             for record in artifacts:
+                # will swtich to True after the successful upload / saving
+                if hasattr(record, "_local_filepath") and getattr(
+                    record, "_to_store", False
+                ):
+                    record._is_saved_to_storage_location = False
                 record._save_skip_storage()
         using_key = settings._using_key
         store_artifacts(artifacts, using_key=using_key)
@@ -107,26 +120,85 @@ def save(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False) ->
     return None
 
 
-def bulk_create(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False):
+def bulk_create(
+    records: Iterable[SQLRecord],
+    ignore_conflicts: bool | None = False,
+    batch_size: int = 10000,
+):
+    """Create records in batches for safety and performance.
+
+    Args:
+        records: Iterable of SQLRecord objects to create
+        ignore_conflicts: Whether to ignore conflicts during creation
+        batch_size: Number of records to process in each batch. Defaults to 10000.
+    """
     records_by_orm = defaultdict(list)
     for record in records:
         records_by_orm[record.__class__].append(record)
-    for registry, records in records_by_orm.items():
-        registry.objects.bulk_create(records, ignore_conflicts=ignore_conflicts)
-        # records[:] = created  # In-place list update; does not seem to be necessary
 
+    for registry, records_list in records_by_orm.items():
+        total_records = len(records_list)
+        model_name = registry.__name__
+        if total_records > batch_size:
+            logger.warning(
+                f"Starting bulk_create for {total_records} {model_name} records in batches of {batch_size}"
+            )
+
+        # Process records in batches
+        for i in range(0, len(records_list), batch_size):
+            batch = records_list[i : i + batch_size]
+            batch_num = (i // batch_size) + 1
+            total_batches = (total_records + batch_size - 1) // batch_size
+
+            if total_records > batch_size:
+                logger.info(
+                    f"Processing batch {batch_num}/{total_batches} for {model_name}: {len(batch)} records"
+                )
+            registry.objects.bulk_create(batch, ignore_conflicts=ignore_conflicts)
+            # records[:] = created  # In-place list update; does not seem to be necessary
+
+
+def bulk_update(
+    records: Iterable[SQLRecord],
+    ignore_conflicts: bool | None = False,
+    batch_size: int = 10000,
+):
+    """Update records in batches for safety and performance.
 
-def bulk_update(records: Iterable[SQLRecord], ignore_conflicts: bool | None = False):
+    Args:
+        records: Iterable of SQLRecord objects to update
+        ignore_conflicts: Whether to ignore conflicts during update (currently unused but kept for consistency)
+        batch_size: Number of records to process in each batch. If None, processes all at once.
+    """
     records_by_orm = defaultdict(list)
     for record in records:
         records_by_orm[record.__class__].append(record)
-    for registry, records in records_by_orm.items():
+
+    for registry, records_list in records_by_orm.items():
+        total_records = len(records_list)
+        model_name = registry.__name__
+        if total_records > batch_size:
+            logger.warning(
+                f"Starting bulk_update for {total_records} {model_name} records in batches of {batch_size}"
+            )
+
         field_names = [
             field.name
             for field in registry._meta.fields
             if (field.name != "created_at" and field.name != "id")
         ]
-        registry.objects.bulk_update(records, field_names)
+
+        # Process records in batches
+        for i in range(0, len(records_list), batch_size):
+            batch = records_list[i : i + batch_size]
+            batch_num = (i // batch_size) + 1
+            total_batches = (total_records + batch_size - 1) // batch_size
+
+            if total_records > batch_size:
+                logger.info(
+                    f"Processing batch {batch_num}/{total_batches} for {model_name}: {len(batch)} records"
+                )
+            registry.objects.bulk_update(batch, field_names)
 
 
 # This is also used within Artifact.save()
@@ -152,7 +224,7 @@ def check_and_attempt_upload(
         except Exception as exception:
             logger.warning(f"could not upload artifact: {artifact}")
             # clear dangling storages if we were actually uploading or saving
-            if hasattr(artifact, "_to_store") and artifact._to_store:
+            if getattr(artifact, "_to_store", False):
                 artifact._clear_storagekey = auto_storage_key_from_artifact(artifact)
             return exception
         # copies (if on-disk) or moves the temporary file (if in-memory) to the cache
@@ -257,6 +329,8 @@ def store_artifacts(
 
     If any upload fails, subsequent artifacts are cleaned up from the DB.
     """
+    from .artifact import Artifact
+
     exception: Exception | None = None
     # because uploads might fail, we need to maintain a new list
     # of the succeeded uploads
@@ -269,8 +343,20 @@ def store_artifacts(
         exception = check_and_attempt_upload(artifact, using_key)
         if exception is not None:
             break
+
         stored_artifacts += [artifact]
-        # if check_and_attempt_upload was successfull
+        # update to show successful saving
+        # only update if _is_saved_to_storage_location was set to False before
+        # this should be a single transaction for the updates of all the artifacts
+        # but then it would just abort all artifacts, even successfully saved before
+        # TODO: there should also be some kind of exception handling here
+        # but this requires proper refactoring
+        if artifact._is_saved_to_storage_location is False:
+            artifact._is_saved_to_storage_location = True
+            super(
+                Artifact, artifact
+            ).save()  # each .save is a separate transaction here
+        # if check_and_attempt_upload was successful
         # then this can have only ._clear_storagekey from .replace
         exception = check_and_attempt_clearing(
             artifact, raise_file_not_found_error=True, using_key=using_key
@@ -334,7 +420,7 @@ def upload_artifact(
     storage_path, storage_settings = attempt_accessing_path(
         artifact, storage_key, using_key=using_key, access_token=access_token
     )
-    if hasattr(artifact, "_to_store") and artifact._to_store:
+    if getattr(artifact, "_to_store", False):
         logger.save(f"storing artifact '{artifact.uid}' at '{storage_path}'")
         store_file_or_folder(
             artifact._local_filepath,

lamindb/models/schema.py

@@ -52,7 +52,7 @@ if TYPE_CHECKING:
 
     from .artifact import Artifact
     from .project import Project
-    from .query_set import QuerySet
+    from .query_set import QuerySet, SQLRecordList
 
 
 NUMBER_TYPE = "num"
@@ -464,7 +464,10 @@ class Schema(SQLRecord, CanCurate, TracksRun):
     @overload
     def __init__(
         self,
-        features: list[SQLRecord] | list[tuple[Feature, dict]] | None = None,
+        features: list[SQLRecord]
+        | SQLRecordList
+        | list[tuple[Feature, dict]]
+        | None = None,
         index: Feature | None = None,
         slots: dict[str, Schema] | None = None,
         name: str | None = None,
@@ -518,6 +521,10 @@ class Schema(SQLRecord, CanCurate, TracksRun):
         coerce_dtype: bool | None = kwargs.pop("coerce_dtype", False)
         using: bool | None = kwargs.pop("using", None)
         n_features: int | None = kwargs.pop("n", None)
+        kwargs.pop("branch", None)
+        kwargs.pop("branch_id", 1)
+        kwargs.pop("space", None)
+        kwargs.pop("space_id", 1)
         # backward compat
         if not slots:
             if "components" in kwargs:
@@ -580,11 +587,6 @@ class Schema(SQLRecord, CanCurate, TracksRun):
         else:
             validated_kwargs["uid"] = ids.base62_16()
         super().__init__(**validated_kwargs)
-        # manipulating aux fields is easier after calling super().__init__()
-        self.optionals.set(optional_features)
-        self.flexible = flexible
-        if index is not None:
-            self._index_feature_uid = index.uid
 
     def _validate_kwargs_calculate_hash(
         self,
@@ -608,13 +610,16 @@ class Schema(SQLRecord, CanCurate, TracksRun):
     ) -> tuple[list[Feature], dict[str, Any], list[Feature], Registry, bool]:
         optional_features = []
         features_registry: Registry = None
+
         if itype is not None:
             if itype != "Composite":
                 itype = serialize_dtype(itype, is_itype=True)
+
         if index is not None:
             if not isinstance(index, Feature):
                 raise TypeError("index must be a Feature")
             features.insert(0, index)
+
         if features:
             features, configs = get_features_config(features)
             features_registry = validate_features(features)
@@ -642,12 +647,15 @@ class Schema(SQLRecord, CanCurate, TracksRun):
         else:
             dtype = get_type_str(dtype)
         flexible_default = n_features < 0
+
         if flexible is None:
             flexible = flexible_default
+
         if slots:
             itype = "Composite"
             if otype is None:
                 raise InvalidArgument("Please pass otype != None for composite schemas")
+
         if itype is not None and not isinstance(itype, str):
             itype_str = serialize_dtype(itype, is_itype=True)
         else:
@@ -667,8 +675,28 @@ class Schema(SQLRecord, CanCurate, TracksRun):
         }
         n_features_default = -1
         coerce_dtype_default = False
+        aux_dict: dict[str, dict[str, bool | str | list[str]]] = {}
+
+        # TODO: leverage a common abstraction across the properties and this here
+
+        # coerce_dtype (key "0")
         if coerce_dtype:
-            validated_kwargs["_aux"] = {"af": {"0": coerce_dtype}}
+            aux_dict.setdefault("af", {})["0"] = coerce_dtype
+
+        # optional features (key "1")
+        if optional_features:
+            aux_dict.setdefault("af", {})["1"] = [f.uid for f in optional_features]
+
+        # flexible (key "2")
+        if flexible is not None:
+            aux_dict.setdefault("af", {})["2"] = flexible
+
+        # index feature (key "3")
+        if index is not None:
+            aux_dict.setdefault("af", {})["3"] = index.uid
+
+        if aux_dict:
+            validated_kwargs["_aux"] = aux_dict
         if slots:
             list_for_hashing = [component.hash for component in slots.values()]
         else:
@@ -716,9 +744,11 @@ class Schema(SQLRecord, CanCurate, TracksRun):
                         ":".join(sorted(feature_list_for_hashing))
                     )
                 list_for_hashing.append(f"{HASH_CODE['features_hash']}={features_hash}")
+
         self._list_for_hashing = sorted(list_for_hashing)
         schema_hash = hash_string(":".join(self._list_for_hashing))
         validated_kwargs["hash"] = schema_hash
+
         return (
             features,
             validated_kwargs,
@@ -1111,6 +1141,9 @@ class Schema(SQLRecord, CanCurate, TracksRun):
 
     def describe(self, return_str=False) -> None | str:
         """Describe schema."""
+        if self.pk is None:
+            raise ValueError("Schema must be saved before describing")
+
         message = str(self)
         # display slots for composite schemas
         if self.itype == "Composite":

lamindb/models/sqlrecord.py

@@ -28,6 +28,7 @@ from django.db.models.fields.related import (
     ManyToManyRel,
     ManyToOneRel,
 )
+from django.db.models.functions import Lower
 from lamin_utils import colors, logger
 from lamindb_setup import settings as setup_settings
 from lamindb_setup._connect_instance import (
@@ -282,7 +283,7 @@ def validate_fields(record: SQLRecord, kwargs):
 def suggest_records_with_similar_names(
     record: SQLRecord, name_field: str, kwargs
 ) -> SQLRecord | None:
-    """Returns True if found exact match, otherwise False.
+    """Returns a record if found exact match, otherwise None.
 
     Logs similar matches if found.
     """
@@ -305,18 +306,15 @@ def suggest_records_with_similar_names(
     )
     if not queryset.exists():  # empty queryset
         return None
-    s, it, nots = ("", "it", "s") if len(queryset) == 1 else ("s", "one of them", "")
-    msg = f"record{s} with similar {name_field}{s} exist{nots}! did you mean to load {it}?"
-    if IPYTHON:
-        from IPython.display import display
-
-        from lamindb import settings
+    s, it, nots, record_text = (
+        ("", "it", "s", "a record")
+        if len(queryset) == 1
+        else ("s", "one of them", "", "records")
+    )
+    similar_names = ", ".join(f"'{getattr(record, name_field)}'" for record in queryset)
+    msg = f"you are trying to create a record with name='{kwargs[name_field]}' but {record_text} with similar {name_field}{s} exist{nots}: {similar_names}. Did you mean to load {it}?"
+    logger.warning(f"{msg}")
 
-        logger.warning(f"{msg}")
-        if settings._verbosity_int >= 1:
-            display(queryset.df())
-    else:
-        logger.warning(f"{msg}\n{queryset}")
     return None
 
 
@@ -405,9 +403,10 @@ class Registry(ModelBase):
         cls,
         field: StrField | None = None,
         return_field: StrField | None = None,
+        keep: Literal["first", "last", False] = "first",
     ) -> NamedTuple:
         """{}"""  # noqa: D415
-        return _lookup(cls=cls, field=field, return_field=return_field)
+        return _lookup(cls=cls, field=field, return_field=return_field, keep=keep)
 
     def filter(cls, *queries, **expressions) -> QuerySet:
         """Query records.
@@ -467,7 +466,7 @@ class Registry(ModelBase):
     def df(
         cls,
         include: str | list[str] | None = None,
-        features: bool | list[str] = False,
+        features: bool | list[str] | str = False,
         limit: int = 100,
     ) -> pd.DataFrame:
         """Convert to `pd.DataFrame`.
@@ -480,9 +479,11 @@ class Registry(ModelBase):
             include: Related fields to include as columns. Takes strings of
                 form `"ulabels__name"`, `"cell_types__name"`, etc. or a list
                 of such strings.
-            features: If `True`, map all features of the
-                :class:`~lamindb.Feature` registry onto the resulting
-                `DataFrame`. Only available for `Artifact`.
+            features: If a list of feature names, filters
+                :class:`~lamindb.Feature` down to these features.
+                If `True`, prints all features with dtypes in the core schema module.
+                If `"queryset"`, infers the features used within the set of artifacts or records.
+                Only available for `Artifact` and `Record`.
             limit: Maximum number of rows to display from a Pandas DataFrame.
                 Defaults to 100 to reduce database load.
 
@@ -549,8 +550,10 @@ class Registry(ModelBase):
         # we're in the default instance
         if instance is None or instance == "default":
             return QuerySet(model=cls, using=None)
+
         owner, name = get_owner_name_from_identifier(instance)
-        if [owner, name] == setup_settings.instance.slug.split("/"):
+        current_instance_owner_name: list[str] = setup_settings.instance.slug.split("/")
+        if [owner, name] == current_instance_owner_name:
             return QuerySet(model=cls, using=None)
 
         # move on to different instances
@@ -565,6 +568,9 @@ class Registry(ModelBase):
                     f"Failed to load instance {instance}, please check your permissions!"
                 )
             iresult, _ = result
+            # this can happen if querying via an old instance name
+            if [iresult.get("owner"), iresult["name"]] == current_instance_owner_name:
+                return QuerySet(model=cls, using=None)
             # do not use {} syntax below, it gives rise to a dict if the schema modules
             # are empty and then triggers a TypeError in missing_members = source_modules - target_modules
             source_modules = set(  # noqa
@@ -655,23 +661,53 @@ class BaseSQLRecord(models.Model, metaclass=Registry):
     def __init__(self, *args, **kwargs):
         skip_validation = kwargs.pop("_skip_validation", False)
         if not args:
-            if self.__class__.__name__ in {
-                "Artifact",
-                "Collection",
-                "Transform",
-                "Run",
-            }:
+            if (
+                issubclass(self.__class__, SQLRecord)
+                and self.__class__.__name__ != "Storage"
+                # do not save bionty entities in restricted spaces by default
+                and self.__class__.__module__ != "bionty.models"
+            ):
                 from lamindb import context as run_context
 
                 if run_context.space is not None:
-                    kwargs["space"] = run_context.space
+                    current_space = run_context.space
+                elif setup_settings.space is not None:
+                    current_space = setup_settings.space
+
+                if current_space is not None:
+                    if "space_id" in kwargs:
+                        # space_id takes precedence over space
+                        # https://claude.ai/share/f045e5dc-0143-4bc5-b8a4-38309229f75e
+                        if kwargs["space_id"] == 1:  # ignore default space
+                            kwargs.pop("space_id")
+                            kwargs["space"] = current_space
+                    elif "space" in kwargs:
+                        if kwargs["space"] is None:
+                            kwargs["space"] = current_space
+                    else:
+                        kwargs["space"] = current_space
             if issubclass(
                 self.__class__, SQLRecord
             ) and self.__class__.__name__ not in {"Storage", "Source"}:
                 from lamindb import context as run_context
 
                 if run_context.branch is not None:
-                    kwargs["branch"] = run_context.branch
+                    current_branch = run_context.branch
+                elif setup_settings.branch is not None:
+                    current_branch = setup_settings.branch
+
+                if current_branch is not None:
+                    # branch_id takes precedence over branch
+                    # https://claude.ai/share/f045e5dc-0143-4bc5-b8a4-38309229f75e
+                    if "branch_id" in kwargs:
+                        if kwargs["branch_id"] == 1:  # ignore default branch
+                            kwargs.pop("branch_id")
+                            kwargs["branch"] = current_branch
+                    elif "branch" in kwargs:
+                        if kwargs["branch"] is None:
+                            kwargs["branch"] = current_branch
+                    else:
+                        kwargs["branch"] = current_branch
             if skip_validation:
                 super().__init__(**kwargs)
             else:
@@ -743,7 +779,7 @@ class BaseSQLRecord(models.Model, metaclass=Registry):
             super().__init__(*args)
         track_current_key_and_name_values(self)
 
-    def save(self, *args, **kwargs) -> SQLRecord:
+    def save(self: T, *args, **kwargs) -> T:
         """Save.
 
         Always saves to the default database.
@@ -751,6 +787,7 @@ class BaseSQLRecord(models.Model, metaclass=Registry):
         using_key = None
         if "using" in kwargs:
             using_key = kwargs["using"]
+        transfer_config = kwargs.pop("transfer", None)
         db = self._state.db
         pk_on_db = self.pk
         artifacts: list = []
@@ -812,6 +849,20 @@ class BaseSQLRecord(models.Model, metaclass=Registry):
                         f"returning {self.__class__.__name__.lower()} with same hash: {pre_existing_record}"
                     )
                     init_self_from_db(self, pre_existing_record)
+                elif (
+                    self.__class__.__name__ == "Storage"
+                    and isinstance(e, IntegrityError)
+                    and "root" in error_msg
+                    or "uid" in error_msg
+                    and (
+                        "UNIQUE constraint failed" in error_msg
+                        or "duplicate key value violates unique constraint" in error_msg
+                    )
+                ):
+                    # even if uid was in the error message, we can retrieve based on
+                    # the root because it's going to be the same root
+                    pre_existing_record = self.__class__.get(root=self.root)
+                    init_self_from_db(self, pre_existing_record)
                 elif (
                     isinstance(e, ProgrammingError)
                     and hasattr(self, "space")
@@ -834,21 +885,18 @@ class BaseSQLRecord(models.Model, metaclass=Registry):
                     for artifact in artifacts:
                         artifact.save()
                     self.artifacts.add(*artifacts)
-            if hasattr(self, "labels"):
+            if hasattr(self, "labels") and transfer_config == "annotations":
                 from copy import copy
 
-                from lamindb.models._feature_manager import FeatureManager
-
                 # here we go back to original record on the source database
                 self_on_db = copy(self)
                 self_on_db._state.db = db
                 self_on_db.pk = pk_on_db  # manually set the primary key
-                self_on_db.features = FeatureManager(self_on_db)  # type: ignore
                 self.features._add_from(self_on_db, transfer_logs=transfer_logs)
                 self.labels.add_from(self_on_db, transfer_logs=transfer_logs)
             for k, v in transfer_logs.items():
                 if k != "run" and len(v) > 0:
-                    logger.important(f"{k} records: {', '.join(v)}")
+                    logger.important(f"{k}: {', '.join(v)}")
 
         if self.__class__.__name__ in {
             "Artifact",
@@ -901,6 +949,11 @@ class Space(BaseSQLRecord):
     All data in this registry is synchronized from LaminHub so that spaces can be shared and reused across multiple LaminDB instances.
     """
 
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(Lower("name"), name="unique_space_name_lower")
+        ]
+
     id: int = models.SmallAutoField(primary_key=True)
     """Internal id, valid only in one DB instance."""
     name: str = models.CharField(max_length=100, db_index=True)
@@ -909,8 +962,8 @@ class Space(BaseSQLRecord):
         editable=False,
         unique=True,
         max_length=12,
-        default="A",
-        db_default="A",
+        default="aaaaaaaaaaaaa",
+        db_default="aaaaaaaaaaaa",
         db_index=True,
     )
     """Universal id."""
@@ -963,6 +1016,11 @@ class Branch(BaseSQLRecord):
     # that can be merged onto the main branch in an experience akin to a Pull Request. The mapping
     # onto a semantic branch name is handled through LaminHub.
 
+    class Meta:
+        constraints = [
+            models.UniqueConstraint(Lower("name"), name="unique_branch_name_lower")
+        ]
+
     id: int = models.AutoField(primary_key=True)
     """An integer id that's synchronized for a family of coupled database instances.
 
@@ -1273,7 +1331,7 @@ def get_transfer_run(record) -> Run:
     if not cache_using_filepath.exists():
         raise SystemExit("Need to call .using() before")
     instance_uid = cache_using_filepath.read_text().split("\n")[0]
-    key = f"transfers/{instance_uid}"
+    key = f"__lamindb_transfer__/{instance_uid}"
     uid = instance_uid + "0000"
     transform = Transform.filter(uid=uid).one_or_none()
     if transform is None:
@@ -1291,9 +1349,7 @@ def get_transfer_run(record) -> Run:
             logger.warning(WARNING_RUN_TRANSFORM)
         initiated_by_run = None
     # it doesn't seem to make sense to create new runs for every transfer
-    run = Run.filter(
-        transform=transform, initiated_by_run=initiated_by_run
-    ).one_or_none()
+    run = Run.filter(transform=transform, initiated_by_run=initiated_by_run).first()
     if run is None:
         run = Run(transform=transform, initiated_by_run=initiated_by_run).save()  # type: ignore
         run.initiated_by_run = initiated_by_run  # so that it's available in memory
@@ -1311,6 +1367,7 @@ def transfer_to_default_db(
     if record._state.db is None or record._state.db == "default":
         return None
     registry = record.__class__
+    logger.debug(f"transferring {registry.__name__} record {record.uid} to default db")
     record_on_default = registry.objects.filter(uid=record.uid).one_or_none()
     record_str = f"{record.__class__.__name__}(uid='{record.uid}')"
     if transfer_logs["run"] is None:
@@ -1366,7 +1423,15 @@ def track_current_key_and_name_values(record: SQLRecord):
 
 def check_name_change(record: SQLRecord):
     """Warns if a record's name has changed."""
-    from lamindb.models import Artifact, Collection, Feature, Schema, Transform
+    from lamindb.models import (
+        Artifact,
+        Collection,
+        Feature,
+        Record,
+        Schema,
+        Storage,
+        Transform,
+    )
 
     if (
         not record.pk
@@ -1389,7 +1454,7 @@ def check_name_change(record: SQLRecord):
 
     if old_name != new_name:
         # when a label is renamed, only raise a warning if it has a feature
-        if hasattr(record, "artifacts"):
+        if hasattr(record, "artifacts") and not isinstance(record, (Record, Storage)):
             linked_records = (
                 record.artifacts.through.filter(
                     label_ref_is_name=True, **{f"{registry.lower()}_id": record.pk}