lamindb 1.3.2__py3-none-any.whl → 1.5.0__py3-none-any.whl

lamindb/models/record.py

@@ -5,7 +5,6 @@ import inspect
 import re
 import sys
 from collections import defaultdict
-from functools import reduce
 from itertools import chain
 from pathlib import PurePosixPath
 from typing import (
@@ -21,36 +20,15 @@ from typing import (
 import dj_database_url
 import lamindb_setup as ln_setup
 from django.core.exceptions import ValidationError as DjangoValidationError
-from django.db import IntegrityError, connections, models, transaction
-from django.db.models import (
-    CASCADE,
-    PROTECT,
-    Field,
-    IntegerField,
-    Manager,
-    Q,
-    QuerySet,
-    Value,
-)
+from django.db import IntegrityError, ProgrammingError, connections, models, transaction
+from django.db.models import CASCADE, PROTECT, Field, Manager, QuerySet
 from django.db.models.base import ModelBase
 from django.db.models.fields.related import (
     ManyToManyField,
     ManyToManyRel,
     ManyToOneRel,
 )
-from django.db.models.functions import Cast, Coalesce
-from django.db.models.lookups import (
-    Contains,
-    Exact,
-    IContains,
-    IExact,
-    IRegex,
-    IStartsWith,
-    Regex,
-    StartsWith,
-)
 from lamin_utils import colors, logger
-from lamin_utils._lookup import Lookup
 from lamindb_setup import settings as setup_settings
 from lamindb_setup._connect_instance import (
     get_owner_name_from_identifier,
@@ -60,25 +38,25 @@ from lamindb_setup._connect_instance import (
 from lamindb_setup.core._docs import doc_args
 from lamindb_setup.core._hub_core import connect_instance_hub
 from lamindb_setup.core._settings_store import instance_settings_file
+from lamindb_setup.core.django import DBToken, db_token_manager
 from lamindb_setup.core.upath import extract_suffix_from_path
 
-from lamindb.base import deprecated
-from lamindb.base.fields import (
+from ..base.fields import (
     CharField,
     DateTimeField,
     ForeignKey,
     JSONField,
-    TextField,
 )
-from lamindb.base.types import FieldAttr, StrField
-from lamindb.errors import FieldValidationError
-
+from ..base.types import FieldAttr, StrField
 from ..errors import (
+    FieldValidationError,
     InvalidArgument,
+    NoWriteAccess,
     RecordNameChangeIntegrityError,
     ValidationError,
 )
 from ._is_versioned import IsVersioned
+from .query_manager import QueryManager, _lookup, _search
 
 if TYPE_CHECKING:
     from datetime import datetime
@@ -183,14 +161,19 @@ def init_self_from_db(self: Record, existing_record: Record):
 
 def update_attributes(record: Record, attributes: dict[str, str]):
     for key, value in attributes.items():
-        if (
-            getattr(record, key) != value
-            and value is not None
-            and key != "dtype"
-            and key != "_aux"
-        ):
-            logger.warning(f"updated {key} from {getattr(record, key)} to {value}")
-            setattr(record, key, value)
+        if getattr(record, key) != value and value is not None:
+            if key not in {"uid", "dtype", "otype", "hash"}:
+                logger.warning(f"updated {key} from {getattr(record, key)} to {value}")
+                setattr(record, key, value)
+            else:
+                hash_message = (
+                    "recomputing on .save()"
+                    if key == "hash"
+                    else f"keeping {getattr(record, key)}"
+                )
+                logger.warning(
+                    f"ignoring tentative value {value} for {key}, {hash_message}"
+                )
 
 
 def validate_literal_fields(record: Record, kwargs) -> None:
@@ -278,9 +261,12 @@ def validate_fields(record: Record, kwargs):
             "uid"
         ).max_length  # triggers FieldDoesNotExist
         if len(kwargs["uid"]) != uid_max_length:  # triggers KeyError
-            raise ValidationError(
-                f"`uid` must be exactly {uid_max_length} characters long, got {len(kwargs['uid'])}."
-            )
+            if not (
+                record.__class__ is Schema and len(kwargs["uid"]) == 16
+            ):  # no error for schema
+                raise ValidationError(
+                    f"`uid` must be exactly {uid_max_length} characters long, got {len(kwargs['uid'])}."
+                )
     # validate is_type
     if "is_type" in kwargs and "name" in kwargs and kwargs["is_type"]:
         if kwargs["name"].endswith("s"):
@@ -370,6 +356,8 @@ class Registry(ModelBase):
     Note: `Registry` inherits from Django's `ModelBase`.
     """
 
+    _available_fields: set[str] = None
+
     def __new__(cls, name, bases, attrs, **kwargs):
         new_class = super().__new__(cls, name, bases, attrs, **kwargs)
         return new_class
@@ -411,36 +399,13 @@ class Registry(ModelBase):
     def __repr__(cls) -> str:
         return registry_repr(cls)
 
+    @doc_args(_lookup.__doc__)
     def lookup(
         cls,
         field: StrField | None = None,
         return_field: StrField | None = None,
     ) -> NamedTuple:
-        """Return an auto-complete object for a field.
-
-        Args:
-            field: The field to look up the values for. Defaults to first string field.
-            return_field: The field to return. If `None`, returns the whole record.
-
-        Returns:
-            A `NamedTuple` of lookup information of the field values with a
-            dictionary converter.
-
-        See Also:
-            :meth:`~lamindb.models.Record.search`
-
-        Examples:
-            >>> import bionty as bt
-            >>> bt.settings.organism = "human"
-            >>> bt.Gene.from_source(symbol="ADGB-DT").save()
-            >>> lookup = bt.Gene.lookup()
-            >>> lookup.adgb_dt
-            >>> lookup_dict = lookup.dict()
-            >>> lookup_dict['ADGB-DT']
-            >>> lookup_by_ensembl_id = bt.Gene.lookup(field="ensembl_gene_id")
-            >>> genes.ensg00000002745
-            >>> lookup_return_symbols = bt.Gene.lookup(field="ensembl_gene_id", return_field="symbol")
-        """
+        """{}"""  # noqa: D415
         return _lookup(cls=cls, field=field, return_field=return_field)
 
     def filter(cls, *queries, **expressions) -> QuerySet:
@@ -487,10 +452,12 @@ class Registry(ModelBase):
             - Guide: :doc:`docs:registries`
             - Django documentation: `Queries <https://docs.djangoproject.com/en/stable/topics/db/queries/>`__
 
-        Examples::
+        Examples:
+
+            ::
 
-            ulabel = ln.ULabel.get("FvtpPJLJ")
-            ulabel = ln.ULabel.get(name="my-label")
+                ulabel = ln.ULabel.get("FvtpPJLJ")
+                ulabel = ln.ULabel.get(name="my-label")
         """
         from .query_set import QuerySet
 
@@ -538,6 +505,7 @@ class Registry(ModelBase):
             query_set = query_set.order_by("-updated_at")
         return query_set[:limit].df(include=include, features=features)
 
+    @doc_args(_search.__doc__)
     def search(
         cls,
         string: str,
@@ -546,27 +514,7 @@ class Registry(ModelBase):
         limit: int | None = 20,
         case_sensitive: bool = False,
     ) -> QuerySet:
-        """Search.
-
-        Args:
-            string: The input string to match against the field ontology values.
-            field: The field or fields to search. Search all string fields by default.
-            limit: Maximum amount of top results to return.
-            case_sensitive: Whether the match is case sensitive.
-
-        Returns:
-            A sorted `DataFrame` of search results with a score in column `score`.
-            If `return_queryset` is `True`.  `QuerySet`.
-
-        See Also:
-            :meth:`~lamindb.models.Record.filter`
-            :meth:`~lamindb.models.Record.lookup`
-
-        Examples:
-            >>> ulabels = ln.ULabel.from_values(["ULabel1", "ULabel2", "ULabel3"], field="name")
-            >>> ln.save(ulabels)
-            >>> ln.ULabel.search("ULabel2")
-        """
+        """{}"""  # noqa: D415
         return _search(
             cls=cls,
             string=string,
@@ -594,17 +542,21 @@ class Registry(ModelBase):
         """
         from .query_set import QuerySet
 
-        if instance is None:
+        # connection already established
+        if instance in connections:
+            return QuerySet(model=cls, using=instance)
+        # 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 f"{owner}/{name}" == setup_settings.instance.slug:
+        if [owner, name] == setup_settings.instance.slug.split("/"):
             return QuerySet(model=cls, using=None)
 
-        settings_file = instance_settings_file(name, owner)
-        cache_filepath = (
-            ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
+        # move on to different instances
+        cache_using_filepath = (
+            setup_settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
         )
+        settings_file = instance_settings_file(name, owner)
         if not settings_file.exists():
             result = connect_instance_hub(owner=owner, name=name)
             if isinstance(result, str):
@@ -613,24 +565,46 @@ class Registry(ModelBase):
                 )
             iresult, _ = result
             # 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_module - target_module
-            source_module = set(  # noqa
+            # are empty and then triggers a TypeError in missing_members = source_modules - target_modules
+            source_modules = set(  # noqa
                 [mod for mod in iresult["schema_str"].split(",") if mod != ""]
             )
-            target_module = ln_setup.settings.instance.modules
-            if not source_module.issubset(target_module):
-                missing_members = source_module - target_module
-                logger.warning(
-                    f"source modules has additional modules: {missing_members}\nconsider mounting these registry modules to transfer all metadata"
-                )
-            cache_filepath.write_text(f"{iresult['lnid']}\n{iresult['schema_str']}")  # type: ignore
-            settings_file = instance_settings_file(name, owner)
+            # this just retrives the full connection string from iresult
             db = update_db_using_local(iresult, settings_file)
+            cache_using_filepath.write_text(
+                f"{iresult['lnid']}\n{iresult['schema_str']}"
+            )
+            # need to set the token if it is a fine_grained_access and the user is jwt (not public)
+            is_fine_grained_access = (
+                iresult["fine_grained_access"] and iresult["db_permissions"] == "jwt"
+            )
+            # access_db can take both: the dict from connect_instance_hub and isettings
+            into_db_token = iresult
         else:
             isettings = load_instance_settings(settings_file)
+            source_modules = isettings.modules
             db = isettings.db
-            cache_filepath.write_text(f"{isettings.uid}\n{','.join(isettings.modules)}")  # type: ignore
+            cache_using_filepath.write_text(
+                f"{isettings.uid}\n{','.join(source_modules)}"
+            )
+            # need to set the token if it is a fine_grained_access and the user is jwt (not public)
+            is_fine_grained_access = (
+                isettings._fine_grained_access and isettings._db_permissions == "jwt"
+            )
+            # access_db can take both: the dict from connect_instance_hub and isettings
+            into_db_token = isettings
+
+        target_modules = setup_settings.instance.modules
+        if missing_members := source_modules - target_modules:
+            logger.warning(
+                f"source modules has additional modules: {missing_members}\n"
+                "consider mounting these registry modules to transfer all metadata"
+            )
+
         add_db_connection(db, instance)
+        if is_fine_grained_access:
+            db_token = DBToken(into_db_token)
+            db_token_manager.set(db_token, instance)
         return QuerySet(model=cls, using=instance)
 
     def __get_module_name__(cls) -> str:
@@ -640,10 +614,6 @@ class Registry(ModelBase):
             module_name = "core"
         return module_name
 
-    @deprecated("__get_module_name__")
-    def __get_schema_name__(cls) -> str:
-        return cls.__get_module_name__()
-
     def __get_name_with_module__(cls) -> str:
         module_name = cls.__get_module_name__()
         if module_name == "core":
@@ -652,9 +622,19 @@ class Registry(ModelBase):
             module_prefix = f"{module_name}."
         return f"{module_prefix}{cls.__name__}"
 
-    @deprecated("__get_name_with_module__")
-    def __get_name_with_schema__(cls) -> str:
-        return cls.__get_name_with_module__()
+    def __get_available_fields__(cls) -> set[str]:
+        if cls._available_fields is None:
+            cls._available_fields = {
+                f.name
+                for f in cls._meta.get_fields()
+                if not f.name.startswith("_")
+                and not f.name.startswith("links_")
+                and not f.name.endswith("_id")
+            }
+            if cls.__name__ == "Artifact":
+                cls._available_fields.add("visibility")
+                cls._available_fields.add("transform")
+        return cls._available_fields
 
 
 class BasicRecord(models.Model, metaclass=Registry):
@@ -665,80 +645,89 @@ class BasicRecord(models.Model, metaclass=Registry):
     It's mainly used for LinkORMs and similar.
     """
 
+    objects = QueryManager()
+
     class Meta:
         abstract = True
+        base_manager_name = "objects"
 
     def __init__(self, *args, **kwargs):
         skip_validation = kwargs.pop("_skip_validation", False)
-        if not args and skip_validation:
-            super().__init__(**kwargs)
-        elif not args and not skip_validation:
-            from ..core._settings import settings
-            from .can_curate import CanCurate
-            from .collection import Collection
-            from .schema import Schema
-            from .transform import Transform
-
-            validate_fields(self, kwargs)
-
-            # do not search for names if an id is passed; this is important
-            # e.g. when synching ids from the notebook store to lamindb
-            has_consciously_provided_uid = False
-            if "_has_consciously_provided_uid" in kwargs:
-                has_consciously_provided_uid = kwargs.pop(
-                    "_has_consciously_provided_uid"
-                )
+        if not args:
             if (
-                isinstance(self, (CanCurate, Collection, Transform))
-                and settings.creation.search_names
-                and not has_consciously_provided_uid
+                issubclass(self.__class__, Record)
+                and self.__class__.__name__
+                not in {"Storage", "ULabel", "Feature", "Schema", "Param"}
+                # do not save bionty entities in restricted spaces by default
+                and self.__class__.__module__ != "bionty.models"
             ):
-                name_field = getattr(self, "_name_field", "name")
-                exact_match = suggest_records_with_similar_names(
-                    self, name_field, kwargs
-                )
-                if exact_match is not None:
-                    if "version" in kwargs:
-                        if kwargs["version"] is not None:
-                            version_comment = " and version"
-                            existing_record = self.__class__.filter(
-                                **{
-                                    name_field: kwargs[name_field],
-                                    "version": kwargs["version"],
-                                }
-                            ).one_or_none()
+                from lamindb import context as run_context
+
+                if run_context.space is not None:
+                    kwargs["space"] = run_context.space
+            if skip_validation:
+                super().__init__(**kwargs)
+            else:
+                from ..core._settings import settings
+                from .can_curate import CanCurate
+                from .collection import Collection
+                from .transform import Transform
+
+                validate_fields(self, kwargs)
+
+                # do not search for names if an id is passed; this is important
+                # e.g. when synching ids from the notebook store to lamindb
+                has_consciously_provided_uid = False
+                if "_has_consciously_provided_uid" in kwargs:
+                    has_consciously_provided_uid = kwargs.pop(
+                        "_has_consciously_provided_uid"
+                    )
+                if (
+                    isinstance(self, (CanCurate, Collection, Transform))
+                    and settings.creation.search_names
+                    and not has_consciously_provided_uid
+                ):
+                    name_field = getattr(self, "_name_field", "name")
+                    exact_match = suggest_records_with_similar_names(
+                        self, name_field, kwargs
+                    )
+                    if exact_match is not None:
+                        if "version" in kwargs:
+                            if kwargs["version"] is not None:
+                                version_comment = " and version"
+                                existing_record = self.__class__.filter(
+                                    **{
+                                        name_field: kwargs[name_field],
+                                        "version": kwargs["version"],
+                                    }
+                                ).one_or_none()
+                            else:
+                                # for a versioned record, an exact name match is not a criterion
+                                # for retrieving a record in case `version` isn't passed -
+                                # we'd always pull out many records with exactly the same name
+                                existing_record = None
                         else:
-                            # for a versioned record, an exact name match is not a criterion
-                            # for retrieving a record in case `version` isn't passed -
-                            # we'd always pull out many records with exactly the same name
-                            existing_record = None
-                    else:
-                        version_comment = ""
-                        existing_record = exact_match
-                    if existing_record is not None:
-                        logger.important(
-                            f"returning existing {self.__class__.__name__} record with same"
-                            f" {name_field}{version_comment}: '{kwargs[name_field]}'"
-                        )
-                        if isinstance(self, Schema):
-                            if existing_record.hash != kwargs["hash"]:
-                                raise ValueError(
-                                    f"Schema name is already in use by schema with uid '{existing_record.uid}', please choose a different name."
-                                )
-                        init_self_from_db(self, existing_record)
-                        update_attributes(self, kwargs)
-                        return None
-            super().__init__(**kwargs)
-            if isinstance(self, ValidateFields):
-                # this will trigger validation against django validators
-                try:
-                    if hasattr(self, "clean_fields"):
-                        self.clean_fields()
-                    else:
-                        self._Model__clean_fields()
-                except DjangoValidationError as e:
-                    message = _format_django_validation_error(self, e)
-                    raise FieldValidationError(message) from e
+                            version_comment = ""
+                            existing_record = exact_match
+                        if existing_record is not None:
+                            logger.important(
+                                f"returning existing {self.__class__.__name__} record with same"
+                                f" {name_field}{version_comment}: '{kwargs[name_field]}'"
+                            )
+                            init_self_from_db(self, existing_record)
+                            update_attributes(self, kwargs)
+                            return None
+                super().__init__(**kwargs)
+                if isinstance(self, ValidateFields):
+                    # this will trigger validation against django validators
+                    try:
+                        if hasattr(self, "clean_fields"):
+                            self.clean_fields()
+                        else:
+                            self._Model__clean_fields()
+                    except DjangoValidationError as e:
+                        message = _format_django_validation_error(self, e)
+                        raise FieldValidationError(message) from e
         elif len(args) != len(self._meta.concrete_fields):
             raise FieldValidationError(
                 f"Use keyword arguments instead of positional arguments, e.g.: {self.__class__.__name__}(name='...')."
@@ -797,20 +786,33 @@ class BasicRecord(models.Model, metaclass=Registry):
                 # save unversioned record
                 else:
                     super().save(*args, **kwargs)
-            except IntegrityError as e:
+            except (IntegrityError, ProgrammingError) as e:
                 error_msg = str(e)
                 # two possible error messages for hash duplication
                 # "duplicate key value violates unique constraint"
                 # "UNIQUE constraint failed"
                 if (
-                    "UNIQUE constraint failed" in error_msg
-                    or "duplicate key value violates unique constraint" in error_msg
-                ) and "hash" in error_msg:
+                    isinstance(e, IntegrityError)
+                    and "hash" in error_msg
+                    and (
+                        "UNIQUE constraint failed" in error_msg
+                        or "duplicate key value violates unique constraint" in error_msg
+                    )
+                ):
                     pre_existing_record = self.__class__.get(hash=self.hash)
                     logger.warning(
                         f"returning {self.__class__.__name__.lower()} with same hash: {pre_existing_record}"
                     )
                     init_self_from_db(self, pre_existing_record)
+                elif (
+                    isinstance(e, ProgrammingError)
+                    and hasattr(self, "space")
+                    and "new row violates row-level security policy" in error_msg
+                ):
+                    raise NoWriteAccess(
+                        f"You’re not allowed to write to the space '{self.space.name}'.\n"
+                        "Please contact an administrator of the space if you need write access."
+                    ) from None
                 else:
                     raise
             # call the below in case a user makes more updates to the record
@@ -840,16 +842,20 @@ class BasicRecord(models.Model, metaclass=Registry):
                 if k != "run":
                     logger.important(f"{k} records: {', '.join(v)}")
 
-        if self.__class__.__name__ in {
-            "Artifact",
-            "Transform",
-            "Run",
-            "ULabel",
-            "Feature",
-            "Schema",
-            "Collection",
-            "Reference",
-        }:
+        if (
+            self.__class__.__name__
+            in {
+                "Artifact",
+                "Transform",
+                "Run",
+                "ULabel",
+                "Feature",
+                "Schema",
+                "Collection",
+                "Reference",
+            }
+            and self._branch_code >= 1
+        ):
             import lamindb as ln
 
             if ln.context.project is not None:
@@ -882,7 +888,7 @@ class BasicRecord(models.Model, metaclass=Registry):
 
 
 class Space(BasicRecord):
-    """Spaces.
+    """Spaces to restrict access to records to specific users or teams.
 
     You can use spaces to restrict access to records within an instance.
 
@@ -1063,146 +1069,6 @@ def _get_record_kwargs(record_class) -> list[tuple[str, str]]:
     return []
 
 
-def _search(
-    cls,
-    string: str,
-    *,
-    field: StrField | list[StrField] | None = None,
-    limit: int | None = 20,
-    case_sensitive: bool = False,
-    truncate_string: bool = False,
-) -> QuerySet:
-    if string is None:
-        raise ValueError("Cannot search for None value! Please pass a valid string.")
-
-    input_queryset = (
-        cls.all() if isinstance(cls, (QuerySet, Manager)) else cls.objects.all()
-    )
-    registry = input_queryset.model
-    name_field = getattr(registry, "_name_field", "name")
-    if field is None:
-        fields = [
-            field.name
-            for field in registry._meta.fields
-            if field.get_internal_type() in {"CharField", "TextField"}
-        ]
-    else:
-        if not isinstance(field, list):
-            fields_input = [field]
-        else:
-            fields_input = field
-        fields = []
-        for field in fields_input:
-            if not isinstance(field, str):
-                try:
-                    fields.append(field.field.name)
-                except AttributeError as error:
-                    raise TypeError(
-                        "Please pass a Record string field, e.g., `CellType.name`!"
-                    ) from error
-            else:
-                fields.append(field)
-
-    if truncate_string:
-        if (len_string := len(string)) > 5:
-            n_80_pct = int(len_string * 0.8)
-            string = string[:n_80_pct]
-
-    string = string.strip()
-    string_escape = re.escape(string)
-
-    exact_lookup = Exact if case_sensitive else IExact
-    regex_lookup = Regex if case_sensitive else IRegex
-    contains_lookup = Contains if case_sensitive else IContains
-
-    ranks = []
-    contains_filters = []
-    for field in fields:
-        field_expr = Coalesce(
-            Cast(field, output_field=TextField()),
-            Value(""),
-            output_field=TextField(),
-        )
-        # exact rank
-        exact_expr = exact_lookup(field_expr, string)
-        exact_rank = Cast(exact_expr, output_field=IntegerField()) * 200
-        ranks.append(exact_rank)
-        # exact synonym
-        synonym_expr = regex_lookup(field_expr, rf"(?:^|.*\|){string_escape}(?:\|.*|$)")
-        synonym_rank = Cast(synonym_expr, output_field=IntegerField()) * 200
-        ranks.append(synonym_rank)
-        # match as sub-phrase
-        sub_expr = regex_lookup(
-            field_expr, rf"(?:^|.*[ \|\.,;:]){string_escape}(?:[ \|\.,;:].*|$)"
-        )
-        sub_rank = Cast(sub_expr, output_field=IntegerField()) * 10
-        ranks.append(sub_rank)
-        # startswith and avoid matching string with " " on the right
-        # mostly for truncated
-        startswith_expr = regex_lookup(
-            field_expr, rf"(?:^|.*\|){string_escape}[^ ]*(?:\|.*|$)"
-        )
-        startswith_rank = Cast(startswith_expr, output_field=IntegerField()) * 8
-        ranks.append(startswith_rank)
-        # match as sub-phrase from the left, mostly for truncated
-        right_expr = regex_lookup(field_expr, rf"(?:^|.*[ \|]){string_escape}.*")
-        right_rank = Cast(right_expr, output_field=IntegerField()) * 2
-        ranks.append(right_rank)
-        # match as sub-phrase from the right
-        left_expr = regex_lookup(field_expr, rf".*{string_escape}(?:$|[ \|\.,;:].*)")
-        left_rank = Cast(left_expr, output_field=IntegerField()) * 2
-        ranks.append(left_rank)
-        # simple contains filter
-        contains_expr = contains_lookup(field_expr, string)
-        contains_filter = Q(contains_expr)
-        contains_filters.append(contains_filter)
-        # also rank by contains
-        contains_rank = Cast(contains_expr, output_field=IntegerField())
-        ranks.append(contains_rank)
-        # additional rule for truncated strings
-        # weight matches from the beginning of the string higher
-        # sometimes whole words get truncated and startswith_expr is not enough
-        if truncate_string and field == name_field:
-            startswith_lookup = StartsWith if case_sensitive else IStartsWith
-            name_startswith_expr = startswith_lookup(field_expr, string)
-            name_startswith_rank = (
-                Cast(name_startswith_expr, output_field=IntegerField()) * 2
-            )
-            ranks.append(name_startswith_rank)
-
-    ranked_queryset = (
-        input_queryset.filter(reduce(lambda a, b: a | b, contains_filters))
-        .alias(rank=sum(ranks))
-        .order_by("-rank")
-    )
-
-    return ranked_queryset[:limit]
-
-
-def _lookup(
-    cls,
-    field: StrField | None = None,
-    return_field: StrField | None = None,
-    using_key: str | None = None,
-) -> NamedTuple:
-    """{}"""  # noqa: D415
-    queryset = cls.all() if isinstance(cls, (QuerySet, Manager)) else cls.objects.all()
-    field = get_name_field(registry=queryset.model, field=field)
-
-    return Lookup(
-        records=queryset,
-        values=[i.get(field) for i in queryset.values()],
-        tuple_name=cls.__class__.__name__,
-        prefix="ln",
-    ).lookup(
-        return_field=(
-            get_name_field(registry=queryset.model, field=return_field)
-            if return_field is not None
-            else None
-        )
-    )
-
-
 def get_name_field(
     registry: type[Record] | QuerySet | Manager,
     *,
@@ -1315,10 +1181,12 @@ def get_transfer_run(record) -> Run:
 
     slug = record._state.db
     owner, name = get_owner_name_from_identifier(slug)
-    cache_filepath = ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
-    if not cache_filepath.exists():
+    cache_using_filepath = (
+        ln_setup.settings.cache_dir / f"instance--{owner}--{name}--uid.txt"
+    )
+    if not cache_using_filepath.exists():
         raise SystemExit("Need to call .using() before")
-    instance_uid = cache_filepath.read_text().split("\n")[0]
+    instance_uid = cache_using_filepath.read_text().split("\n")[0]
     key = f"transfers/{instance_uid}"
     uid = instance_uid + "0000"
     transform = Transform.filter(uid=uid).one_or_none()
@@ -1401,11 +1269,13 @@ def transfer_to_default_db(
 def track_current_key_and_name_values(record: Record):
     from lamindb.models import Artifact
 
+    # below, we're using __dict__ to avoid triggering the refresh from the database
+    # which can lead to a recursion
     if isinstance(record, Artifact):
-        record._old_key = record.key
-        record._old_suffix = record.suffix
+        record._old_key = record.__dict__.get("key")
+        record._old_suffix = record.__dict__.get("suffix")
     elif hasattr(record, "_name_field"):
-        record._old_name = getattr(record, record._name_field)
+        record._old_name = record.__dict__.get(record._name_field)
 
 
 def check_name_change(record: Record):
@@ -1439,9 +1309,6 @@ def check_name_change(record: Record):
                     label_ref_is_name=True, **{f"{registry.lower()}_id": record.pk}
                 )
                 .exclude(feature_id=None)  # must have a feature
-                .exclude(
-                    feature_ref_is_name=None
-                )  # must be linked via Curator and therefore part of a schema
                 .distinct()
             )
             artifact_ids = linked_records.list("artifact__uid")